diff --git a/src/App.tsx b/src/App.tsx
index 0bf199c06..16bf28bd2 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -39,6 +39,7 @@ import { useCheckBonusEligibility } from "./hooks/useCheckBonusEligibility"
 import { useFetchStakingRewards } from "./hooks/useFetchStakingRewards"
 import { isSameETHAddress } from "./web3/utils"
 import { ThresholdProvider } from "./contexts/ThresholdContext"
+import { useSubscribeToAuthorizationIncreasedEvent } from "./hooks/staking-applications"
 
 const Web3EventHandlerComponent = () => {
   useSubscribeToVendingMachineContractEvents()
@@ -48,6 +49,8 @@ const Web3EventHandlerComponent = () => {
   useSubscribeToStakedEvent()
   useSubscribeToUnstakedEvent()
   useSubscribeToToppedUpEvent()
+  useSubscribeToAuthorizationIncreasedEvent("tbtc")
+  useSubscribeToAuthorizationIncreasedEvent("randomBeacon")
 
   return <></>
 }
diff --git a/src/contexts/ThresholdContext.tsx b/src/contexts/ThresholdContext.tsx
index 3fb20f9c7..f2881e743 100644
--- a/src/contexts/ThresholdContext.tsx
+++ b/src/contexts/ThresholdContext.tsx
@@ -1,34 +1,43 @@
-import { createContext, FC, useContext, useMemo } from "react"
+import { createContext, FC, useContext, useEffect, useRef } from "react"
 import { useWeb3React } from "@web3-react/core"
-import { JsonRpcProvider, Provider } from "@ethersproject/providers"
-import { Signer } from "ethers"
-import { Threshold } from "../threshold-ts"
-import { EnvVariable } from "../enums"
-import { getEnvVariable, supportedChainId } from "../utils/getEnvVariable"
+import {
+  getDefaultThresholdLibProvider,
+  threshold,
+} from "../utils/getThresholdLib"
+import { supportedChainId } from "../utils/getEnvVariable"
 
-const getThresholdLib = (providerOrSigner?: Provider | Signer) => {
-  return new Threshold({
-    ethereum: {
-      chainId: supportedChainId,
-      providerOrSigner:
-        providerOrSigner ||
-        new JsonRpcProvider(getEnvVariable(EnvVariable.ETH_HOSTNAME_HTTP)),
-    },
-  })
-}
-
-const ThresholdContext = createContext(getThresholdLib())
+const ThresholdContext = createContext(threshold)
 
 export const useThreshold = () => {
   return useContext(ThresholdContext)
 }
 
 export const ThresholdProvider: FC = ({ children }) => {
-  const { library, active } = useWeb3React()
+  const { library, active, account } = useWeb3React()
+  const hasThresholdLibConfigBeenUpdated = useRef(false)
+
+  useEffect(() => {
+    if (active && library && account) {
+      threshold.updateConfig({
+        ethereum: {
+          chainId: supportedChainId,
+          providerOrSigner: library,
+          account,
+        },
+      })
+      hasThresholdLibConfigBeenUpdated.current = true
+    }
 
-  const threshold = useMemo(() => {
-    return getThresholdLib(active ? library : undefined)
-  }, [library, active])
+    if (!active && !account && hasThresholdLibConfigBeenUpdated.current) {
+      threshold.updateConfig({
+        ethereum: {
+          chainId: supportedChainId,
+          providerOrSigner: getDefaultThresholdLibProvider(),
+        },
+      })
+      hasThresholdLibConfigBeenUpdated.current = false
+    }
+  }, [library, active, account])
 
   return (
     <ThresholdContext.Provider value={threshold}>
diff --git a/src/hooks/staking-applications/index.ts b/src/hooks/staking-applications/index.ts
new file mode 100644
index 000000000..50bcb755b
--- /dev/null
+++ b/src/hooks/staking-applications/index.ts
@@ -0,0 +1,6 @@
+export * from "./useStakingAppContract"
+export * from "./useStakingAppDataByStakingProvider"
+export * from "./useStakingApplicationState"
+export * from "./useStakingAppMinAuthorizationAmount"
+export * from "./useStakingAppParameters"
+export * from "./useSubscribeToAuthorizationIncreasedEvent"
diff --git a/src/hooks/staking-applications/useStakingAppContract.ts b/src/hooks/staking-applications/useStakingAppContract.ts
new file mode 100644
index 000000000..c30ed14c7
--- /dev/null
+++ b/src/hooks/staking-applications/useStakingAppContract.ts
@@ -0,0 +1,11 @@
+import { StakingAppName } from "../../store/staking-applications"
+import { useThreshold } from "../../contexts/ThresholdContext"
+
+const appNameToAppService: Record<StakingAppName, "ecdsa" | "randomBeacon"> = {
+  tbtc: "ecdsa",
+  randomBeacon: "randomBeacon",
+}
+
+export const useStakingAppContract = (appName: StakingAppName) => {
+  return useThreshold().multiAppStaking[appNameToAppService[appName]].contract
+}
diff --git a/src/hooks/staking-applications/useStakingAppDataByStakingProvider.ts b/src/hooks/staking-applications/useStakingAppDataByStakingProvider.ts
new file mode 100644
index 000000000..a13a049f2
--- /dev/null
+++ b/src/hooks/staking-applications/useStakingAppDataByStakingProvider.ts
@@ -0,0 +1,14 @@
+import {
+  selectStakingAppByStakingProvider,
+  StakingAppName,
+} from "../../store/staking-applications"
+import { useAppSelector } from "../store"
+
+export const useStakingAppDataByStakingProvider = (
+  appName: StakingAppName,
+  stakingProvider: string
+) => {
+  return useAppSelector((state) =>
+    selectStakingAppByStakingProvider(state, appName, stakingProvider)
+  )
+}
diff --git a/src/hooks/staking-applications/useStakingAppMinAuthorizationAmount.ts b/src/hooks/staking-applications/useStakingAppMinAuthorizationAmount.ts
new file mode 100644
index 000000000..84a462580
--- /dev/null
+++ b/src/hooks/staking-applications/useStakingAppMinAuthorizationAmount.ts
@@ -0,0 +1,8 @@
+import { StakingAppName } from "../../store/staking-applications"
+import { useStakingAppParameters } from "./useStakingAppParameters"
+
+export const useStakingAppMinAuthorizationAmount = (
+  appName: StakingAppName
+) => {
+  return useStakingAppParameters(appName).data.minimumAuthorization
+}
diff --git a/src/hooks/staking-applications/useStakingAppParameters.ts b/src/hooks/staking-applications/useStakingAppParameters.ts
new file mode 100644
index 000000000..2867156b3
--- /dev/null
+++ b/src/hooks/staking-applications/useStakingAppParameters.ts
@@ -0,0 +1,6 @@
+import { StakingAppName } from "../../store/staking-applications"
+import { useStakingApplicationState } from "./useStakingApplicationState"
+
+export const useStakingAppParameters = (appName: StakingAppName) => {
+  return useStakingApplicationState(appName).parameters
+}
diff --git a/src/hooks/staking-applications/useStakingApplicationState.ts b/src/hooks/staking-applications/useStakingApplicationState.ts
new file mode 100644
index 000000000..065b9ed31
--- /dev/null
+++ b/src/hooks/staking-applications/useStakingApplicationState.ts
@@ -0,0 +1,11 @@
+import {
+  StakingAppName,
+  selectStakingAppStateByAppName,
+} from "../../store/staking-applications"
+import { useAppSelector } from "../store"
+
+export const useStakingApplicationState = (appName: StakingAppName) => {
+  return useAppSelector((state) =>
+    selectStakingAppStateByAppName(state, appName)
+  )
+}
diff --git a/src/hooks/staking-applications/useSubscribeToAuthorizationIncreasedEvent.ts b/src/hooks/staking-applications/useSubscribeToAuthorizationIncreasedEvent.ts
new file mode 100644
index 000000000..5eca9e0a8
--- /dev/null
+++ b/src/hooks/staking-applications/useSubscribeToAuthorizationIncreasedEvent.ts
@@ -0,0 +1,29 @@
+import {
+  stakingApplicationsSlice,
+  StakingAppName,
+} from "../../store/staking-applications"
+import { useSubscribeToContractEvent } from "../../web3/hooks"
+import { useAppDispatch } from "../store"
+import { useStakingAppContract } from "./useStakingAppContract"
+
+export const useSubscribeToAuthorizationIncreasedEvent = (
+  appName: StakingAppName
+) => {
+  const contract = useStakingAppContract(appName)
+  const dispatch = useAppDispatch()
+
+  useSubscribeToContractEvent(
+    contract,
+    "AuthorizationIncreased",
+    // @ts-ignore
+    async (stakingProvider, operator, fromAmount, toAmount) => {
+      dispatch(
+        stakingApplicationsSlice.actions.authorizationIncreased({
+          stakingProvider,
+          toAmount: toAmount.toString(),
+          appName,
+        })
+      )
+    }
+  )
+}
diff --git a/src/hooks/store/index.ts b/src/hooks/store/index.ts
new file mode 100644
index 000000000..20f33eb3c
--- /dev/null
+++ b/src/hooks/store/index.ts
@@ -0,0 +1,2 @@
+export * from "./useAppDispatch"
+export * from "./useAppSelector"
diff --git a/src/hooks/store/useAppDispatch.ts b/src/hooks/store/useAppDispatch.ts
new file mode 100644
index 000000000..2db55760c
--- /dev/null
+++ b/src/hooks/store/useAppDispatch.ts
@@ -0,0 +1,4 @@
+import { useDispatch } from "react-redux"
+import { AppDispatch } from "../../store"
+
+export const useAppDispatch: () => AppDispatch = useDispatch
diff --git a/src/hooks/store/useAppSelector.ts b/src/hooks/store/useAppSelector.ts
new file mode 100644
index 000000000..8338c689b
--- /dev/null
+++ b/src/hooks/store/useAppSelector.ts
@@ -0,0 +1,4 @@
+import { useSelector, TypedUseSelectorHook } from "react-redux"
+import { RootState } from "../../store"
+
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector
diff --git a/src/pages/Staking/AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox/index.tsx b/src/pages/Staking/AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox/index.tsx
index 7f38b9175..634c99f0f 100644
--- a/src/pages/Staking/AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox/index.tsx
+++ b/src/pages/Staking/AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox/index.tsx
@@ -10,6 +10,8 @@ import { FC } from "react"
 import { TokenAmountForm } from "../../../../components/Forms"
 import { AppAuthorizationInfo } from "./AppAuthorizationInfo"
 import { formatTokenAmount } from "../../../../utils/formatAmount"
+import { useThreshold } from "../../../../contexts/ThresholdContext"
+import { WeiPerEther } from "@ethersproject/constants"
 
 export interface AppAuthDataProps {
   label: string
@@ -20,6 +22,7 @@ export interface AppAuthDataProps {
 
 export interface AuthorizeApplicationsCardCheckboxProps extends BoxProps {
   appAuthData: AppAuthDataProps
+  stakingProvider: string
   onCheckboxClick: (app: AppAuthDataProps, isChecked: boolean) => void
   isSelected: boolean
   maxAuthAmount: string
@@ -34,9 +37,21 @@ export const AuthorizeApplicationsCardCheckbox: FC<
   isSelected,
   maxAuthAmount,
   minAuthAmount,
+  stakingProvider,
   ...restProps
 }) => {
   const collapsed = !appAuthData.isAuthRequired
+  const threshold = useThreshold()
+
+  const onAuthorizeApp = async (tokenAmount: string) => {
+    // TODO: Pass the staking provider address as a prop.
+    // TODO: Use `useSendtTransacion` hook to open confirmation modal/pending modals/success modal.
+    // Just test the transacion. The real flow is diffrent- we should opean confirmation modal then trigger transacion.
+    await threshold.multiAppStaking.randomBeacon.increaseAuthorization(
+      stakingProvider,
+      tokenAmount
+    )
+  }
 
   if (collapsed) {
     return (
@@ -93,7 +108,7 @@ export const AuthorizeApplicationsCardCheckbox: FC<
         <AppAuthorizationInfo
           gridArea="app-info"
           label={appAuthData.label}
-          percentageAuthorized={100}
+          percentageAuthorized={appAuthData.percentage}
           aprPercentage={10}
           slashingPercentage={1}
           isAuthorizationRequired={true}
@@ -111,14 +126,16 @@ export const AuthorizeApplicationsCardCheckbox: FC<
         />
         <GridItem gridArea="token-amount-form" mt={5}>
           <TokenAmountForm
-            onSubmitForm={() => {
-              console.log("form submitted")
-            }}
+            onSubmitForm={onAuthorizeApp}
             label="Amount"
             submitButtonText={`Authorize ${appAuthData.label}`}
             maxTokenAmount={maxAuthAmount}
             placeholder={"Enter amount"}
-            minTokenAmount={minAuthAmount}
+            minTokenAmount={
+              appAuthData.percentage === 0
+                ? minAuthAmount
+                : WeiPerEther.toString()
+            }
             helperText={`Minimum ${formatTokenAmount(minAuthAmount)} T for ${
               appAuthData.label
             }`}
diff --git a/src/pages/Staking/AuthorizeStakingApps/index.tsx b/src/pages/Staking/AuthorizeStakingApps/index.tsx
index 565e814f2..4fece5119 100644
--- a/src/pages/Staking/AuthorizeStakingApps/index.tsx
+++ b/src/pages/Staking/AuthorizeStakingApps/index.tsx
@@ -14,7 +14,7 @@ import { useSelector } from "react-redux"
 import { useNavigate, useParams } from "react-router-dom"
 import { RootState } from "../../../store"
 import { PageComponent, StakeData } from "../../../types"
-import { isSameETHAddress } from "../../../web3/utils"
+import { AddressZero, isSameETHAddress, isAddress } from "../../../web3/utils"
 import { StakeCardHeaderTitle } from "../StakeCard/Header/HeaderTitle"
 import AuthorizeApplicationsCardCheckbox, {
   AppAuthDataProps,
@@ -23,7 +23,10 @@ import { useEffect, useState } from "react"
 import { featureFlags } from "../../../constants"
 import { selectStakeByStakingProvider } from "../../../store/staking"
 import { useWeb3React } from "@web3-react/core"
-import { isAddress } from "web3-utils"
+import {
+  useStakingAppDataByStakingProvider,
+  useStakingAppMinAuthorizationAmount,
+} from "../../../hooks/staking-applications"
 
 const AuthorizeStakingAppsPage: PageComponent = (props) => {
   const { stakingProviderAddress } = useParams()
@@ -34,8 +37,18 @@ const AuthorizeStakingAppsPage: PageComponent = (props) => {
     if (!isAddress(stakingProviderAddress!)) navigate(`/staking`)
   }, [stakingProviderAddress, navigate])
 
-  //TODO: This should be fetched from contract for each app
-  const minAuthAmount = "1000000000000000000000"
+  const tbtcMinAuthAmount = useStakingAppMinAuthorizationAmount("tbtc")
+  const randomBeaconMinAuthAmount =
+    useStakingAppMinAuthorizationAmount("randomBeacon")
+
+  const tbtcApp = useStakingAppDataByStakingProvider(
+    "tbtc",
+    stakingProviderAddress || AddressZero
+  )
+  const randomBeaconApp = useStakingAppDataByStakingProvider(
+    "randomBeacon",
+    stakingProviderAddress || AddressZero
+  )
 
   const stake = useSelector((state: RootState) =>
     selectStakeByStakingProvider(state, stakingProviderAddress!)
@@ -48,18 +61,17 @@ const AuthorizeStakingAppsPage: PageComponent = (props) => {
     ? BigNumber.from(stake?.totalInTStake).isZero()
     : false
 
-  // TODO: This will probably be fetched from contracts
   const appsAuthData = {
     tbtc: {
       label: "tBTC",
-      isAuthorized: true,
-      percentage: 40,
+      isAuthorized: tbtcApp.isAuthorized,
+      percentage: tbtcApp.percentage,
       isAuthRequired: true,
     },
     randomBeacon: {
       label: "Random Beacon",
-      isAuthorized: false,
-      percentage: 0,
+      isAuthorized: randomBeaconApp.isAuthorized,
+      percentage: randomBeaconApp.percentage,
       isAuthRequired: true,
     },
     pre: {
@@ -124,7 +136,8 @@ const AuthorizeStakingAppsPage: PageComponent = (props) => {
           onCheckboxClick={onCheckboxClick}
           isSelected={selectedApps.map((app) => app.label).includes("tBTC")}
           maxAuthAmount={stake.totalInTStake}
-          minAuthAmount={minAuthAmount}
+          minAuthAmount={tbtcMinAuthAmount}
+          stakingProvider={stakingProviderAddress!}
         />
         <AuthorizeApplicationsCardCheckbox
           mt={5}
@@ -134,7 +147,8 @@ const AuthorizeStakingAppsPage: PageComponent = (props) => {
             .map((app) => app.label)
             .includes("Random Beacon")}
           maxAuthAmount={stake.totalInTStake}
-          minAuthAmount={minAuthAmount}
+          minAuthAmount={randomBeaconMinAuthAmount}
+          stakingProvider={stakingProviderAddress!}
         />
         <AuthorizeApplicationsCardCheckbox
           mt={5}
@@ -142,7 +156,8 @@ const AuthorizeStakingAppsPage: PageComponent = (props) => {
           onCheckboxClick={onCheckboxClick}
           isSelected={selectedApps.map((app) => app.label).includes("PRE")}
           maxAuthAmount={stake.totalInTStake}
-          minAuthAmount={minAuthAmount}
+          minAuthAmount={"0"}
+          stakingProvider={stakingProviderAddress!}
         />
         <Button
           disabled={selectedApps.length === 0}
diff --git a/src/pages/Staking/StakeCard/StakeApplications/AuthorizeApplicationRow.tsx b/src/pages/Staking/StakeCard/StakeApplications/AuthorizeApplicationRow.tsx
index d1586b454..a0f9f6a8f 100644
--- a/src/pages/Staking/StakeCard/StakeApplications/AuthorizeApplicationRow.tsx
+++ b/src/pages/Staking/StakeCard/StakeApplications/AuthorizeApplicationRow.tsx
@@ -10,6 +10,7 @@ import {
 import { CheckCircleIcon } from "@chakra-ui/icons"
 import { AppAuthDataProps } from "../../AuthorizeStakingApps/AuthorizeApplicationsCardCheckbox"
 import { Link as RouterLink } from "react-router-dom"
+import { formatPercentage } from "../../../../utils/percentage"
 
 export interface AuthorizeApplicationRowProps extends StackProps {
   appAuthData: AppAuthDataProps
@@ -47,7 +48,7 @@ const AuthorizeApplicationRow: FC<AuthorizeApplicationRowProps> = ({
             colorScheme="brand"
             borderRadius={50}
           />
-          <BodySm>{percentage}%</BodySm>
+          <BodySm>{formatPercentage(percentage)}</BodySm>
         </HStack>
       ) : (
         <Button
diff --git a/src/pages/Staking/StakeCard/StakeApplications/index.tsx b/src/pages/Staking/StakeCard/StakeApplications/index.tsx
index 8e45a9d43..d71aa4653 100644
--- a/src/pages/Staking/StakeCard/StakeApplications/index.tsx
+++ b/src/pages/Staking/StakeCard/StakeApplications/index.tsx
@@ -10,24 +10,30 @@ import {
 } from "@threshold-network/components"
 import AuthorizeApplicationRow from "./AuthorizeApplicationRow"
 import { Link as RouterLink } from "react-router-dom"
+import { useStakingAppDataByStakingProvider } from "../../../../hooks/staking-applications"
 
 const StakeApplications: FC<{ stakingProvider: string }> = ({
   stakingProvider,
 }) => {
   const areNodesMissing = true
+  const tbtcApp = useStakingAppDataByStakingProvider("tbtc", stakingProvider)
+  const randomBeaconApp = useStakingAppDataByStakingProvider(
+    "randomBeacon",
+    stakingProvider
+  )
 
   // TODO: This will probably be fetched from contracts
   const appsAuthData = {
     tbtc: {
       label: "tBTC",
-      isAuthorized: true,
-      percentage: 40,
+      isAuthorized: tbtcApp.isAuthorized,
+      percentage: tbtcApp.percentage,
       isAuthRequired: true,
     },
     randomBeacon: {
       label: "Random Beacon",
-      isAuthorized: false,
-      percentage: 0,
+      isAuthorized: randomBeaconApp.isAuthorized,
+      percentage: randomBeaconApp.percentage,
       isAuthRequired: true,
     },
     pre: {
diff --git a/src/pages/Staking/index.tsx b/src/pages/Staking/index.tsx
index 1968533d5..3e557ca68 100644
--- a/src/pages/Staking/index.tsx
+++ b/src/pages/Staking/index.tsx
@@ -9,15 +9,21 @@ import { useFetchTvl } from "../../hooks/useFetchTvl"
 import { useStakingState } from "../../hooks/useStakingState"
 import { PageComponent } from "../../types"
 import HowItWorksPage from "./HowItWorks"
-import { useSelector } from "react-redux"
+import { useDispatch, useSelector } from "react-redux"
 import {
   selectTotalBonusBalance,
   selectTotalRewardsBalance,
 } from "../../store/rewards"
 import AuthorizeStakingAppsPage from "./AuthorizeStakingApps"
+import { stakingApplicationsSlice } from "../../store/staking-applications/slice"
 
 const StakingPage: PageComponent = (props) => {
   const [data, fetchtTvlData] = useFetchTvl()
+  const dispatch = useDispatch()
+
+  useEffect(() => {
+    dispatch(stakingApplicationsSlice.actions.getSupportedApps({}))
+  }, [dispatch])
 
   useEffect(() => {
     fetchtTvlData()
diff --git a/src/store/index.ts b/src/store/index.ts
index ad541538f..556fde190 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -12,6 +12,8 @@ import { stakingSlice } from "./staking"
 import { ethSlice } from "./eth"
 import { rewardsSlice } from "./rewards"
 import { tbtcSlice } from "./tbtc"
+import { stakingApplicationsSlice } from "./staking-applications/slice"
+import { listenerMiddleware } from "./listener"
 
 const combinedReducer = combineReducers({
   modal: modalSlice.reducer,
@@ -22,6 +24,7 @@ const combinedReducer = combineReducers({
   eth: ethSlice.reducer,
   tbtc: tbtcSlice.reducer,
   rewards: rewardsSlice.reducer,
+  applications: stakingApplicationsSlice.reducer,
 })
 
 const APP_RESET_STORE = "app/reset_store"
@@ -68,8 +71,11 @@ const store = configureStore({
           "payload.props.setAmountToStake",
         ],
       },
-    }),
+    }).prepend(listenerMiddleware.middleware),
 })
 
-export type RootState = ReturnType<typeof combinedReducer>
+export type RootState = ReturnType<
+  typeof store.getState & typeof combinedReducer
+>
+export type AppDispatch = typeof store.dispatch
 export default store
diff --git a/src/store/listener.ts b/src/store/listener.ts
new file mode 100644
index 000000000..f4f65b845
--- /dev/null
+++ b/src/store/listener.ts
@@ -0,0 +1,31 @@
+import {
+  createListenerMiddleware,
+  ListenerEffectAPI,
+  TypedStartListening,
+} from "@reduxjs/toolkit"
+import { AppDispatch, RootState } from "."
+import { Threshold } from "../threshold-ts"
+import { threshold } from "../utils/getThresholdLib"
+
+export const listenerMiddleware = createListenerMiddleware({
+  extra: { threshold },
+})
+
+export type ExtraArgument = {
+  threshold: Threshold
+}
+
+export type AppStartListening = TypedStartListening<
+  RootState,
+  AppDispatch,
+  ExtraArgument
+>
+
+export type AppListenerEffectAPI = ListenerEffectAPI<
+  RootState,
+  AppDispatch,
+  ExtraArgument
+>
+
+export const startAppListening =
+  listenerMiddleware.startListening as AppStartListening
diff --git a/src/store/staking-applications/effects.ts b/src/store/staking-applications/effects.ts
new file mode 100644
index 000000000..d059dad67
--- /dev/null
+++ b/src/store/staking-applications/effects.ts
@@ -0,0 +1,152 @@
+import { stakingApplicationsSlice, StakingAppName } from "./slice"
+import { AppListenerEffectAPI } from "../listener"
+import { selectStakingProviders, setStakes } from "../staking"
+import {
+  IApplication,
+  StakingProviderAppInfo,
+} from "../../threshold-ts/applications"
+
+export const getSupportedAppsEffect = async (
+  action: ReturnType<typeof stakingApplicationsSlice.actions.getSupportedApps>,
+  listenerApi: AppListenerEffectAPI
+) => {
+  try {
+    listenerApi.unsubscribe()
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.fetchingAppParameters({
+        appName: "tbtc",
+      })
+    )
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.fetchingAppParameters({
+        appName: "randomBeacon",
+      })
+    )
+    const data =
+      await listenerApi.extra.threshold.multiAppStaking.getSupportedAppsAuthParameters()
+    // one-off listener
+    const payload = {
+      tbtc: {
+        minimumAuthorization: data.tbtc.minimumAuthorization.toString(),
+
+        authorizationDecreaseDelay:
+          data.tbtc.authorizationDecreaseDelay.toString(),
+
+        authorizationDecreaseChangePeriod:
+          data.tbtc.authorizationDecreaseChangePeriod.toString(),
+      },
+      randomBeacon: {
+        minimumAuthorization: data.randomBeacon.minimumAuthorization.toString(),
+
+        authorizationDecreaseDelay:
+          data.randomBeacon.authorizationDecreaseDelay.toString(),
+
+        authorizationDecreaseChangePeriod:
+          data.randomBeacon.authorizationDecreaseChangePeriod.toString(),
+      },
+    }
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setAppParameters({
+        appName: "randomBeacon",
+        parameters: payload.randomBeacon,
+      })
+    )
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setAppParameters({
+        appName: "tbtc",
+        parameters: payload.tbtc,
+      })
+    )
+  } catch (error) {
+    const errorMessage = (error as Error).toString()
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setAppParametersError({
+        appName: "randomBeacon",
+        error: errorMessage,
+      })
+    )
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setAppParametersError({
+        appName: "tbtc",
+        error: errorMessage,
+      })
+    )
+    console.log("Could not fetch supported apps auth parameters", error)
+    listenerApi.subscribe()
+  }
+}
+
+export const getSupportedAppsStakingProvidersData = async (
+  action: ReturnType<typeof setStakes>,
+  listenerApi: AppListenerEffectAPI
+) => {
+  try {
+    const stakingProviders = selectStakingProviders(listenerApi.getState())
+    if (stakingProviders.length === 0) return
+    // one-off listener
+    listenerApi.unsubscribe()
+
+    await getKeepStakingAppStakingProvidersData(
+      stakingProviders,
+      listenerApi.extra.threshold.multiAppStaking.randomBeacon,
+      "randomBeacon",
+      listenerApi
+    )
+
+    await getKeepStakingAppStakingProvidersData(
+      stakingProviders,
+      listenerApi.extra.threshold.multiAppStaking.ecdsa,
+      "tbtc",
+      listenerApi
+    )
+  } catch (error) {
+    console.log("Could not fetch apps data for staking providers ", error)
+    listenerApi.subscribe()
+  }
+}
+
+const getKeepStakingAppStakingProvidersData = async (
+  stakingProviders: string[],
+  application: IApplication,
+  appName: StakingAppName,
+  listenerApi: AppListenerEffectAPI
+) => {
+  try {
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.fetchingStakingProvidersAppData({
+        appName,
+      })
+    )
+    const appData = await Promise.all(
+      stakingProviders.map(application.getStakingProviderAppInfo)
+    )
+    const appDataByStakingProvider = stakingProviders.reduce(
+      (reducer, stakingProvider, index) => {
+        const _appData = appData[index]
+        reducer[stakingProvider] = {
+          authorizedStake: _appData.authorizedStake.toString(),
+          pendingAuthorizationDecrease:
+            _appData.pendingAuthorizationDecrease.toString(),
+          remainingAuthorizationDecreaseDelay:
+            _appData.remainingAuthorizationDecreaseDelay.toString(),
+        }
+        return reducer
+      },
+      {} as { [stakingProvider: string]: StakingProviderAppInfo<string> }
+    )
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setStakingProvidersAppData({
+        appName,
+        data: appDataByStakingProvider,
+      })
+    )
+  } catch (error) {
+    listenerApi.dispatch(
+      stakingApplicationsSlice.actions.setStakingProvidersAppDataError({
+        appName,
+        error: (error as Error).toString(),
+      })
+    )
+    throw error
+  }
+}
diff --git a/src/store/staking-applications/index.ts b/src/store/staking-applications/index.ts
new file mode 100644
index 000000000..e27a75bd2
--- /dev/null
+++ b/src/store/staking-applications/index.ts
@@ -0,0 +1,3 @@
+export * from "./slice"
+export * from "./effects"
+export * from "./selectors"
diff --git a/src/store/staking-applications/selectors.ts b/src/store/staking-applications/selectors.ts
new file mode 100644
index 000000000..2c101751e
--- /dev/null
+++ b/src/store/staking-applications/selectors.ts
@@ -0,0 +1,49 @@
+import { createSelector } from "@reduxjs/toolkit"
+import { RootState } from ".."
+import {
+  StakingApplicationsState,
+  StakingApplicationState,
+  StakingAppName,
+} from "./slice"
+import { selectStakeByStakingProvider } from "../staking"
+import { StakeData } from "../../types"
+import { calculatePercenteage } from "../../utils/percentage"
+import { BigNumber } from "ethers"
+
+export const selectStakingAppState = (state: RootState) => state.applications
+
+export const selectStakingAppStateByAppName = createSelector(
+  [selectStakingAppState, (_: RootState, appName: StakingAppName) => appName],
+  (applicationState: StakingApplicationsState, appName: StakingAppName) => {
+    return applicationState[appName]
+  }
+)
+
+export const selectStakingAppByStakingProvider = createSelector(
+  [
+    (state: RootState, appName: StakingAppName, stakingProvider: string) =>
+      selectStakingAppStateByAppName(state, appName),
+    (_: RootState, appName: StakingAppName, stakingProvider: string) =>
+      stakingProvider,
+    (state: RootState, appName: StakingAppName, stakingProvider: string) =>
+      selectStakeByStakingProvider(state, stakingProvider),
+  ],
+  (
+    appState: StakingApplicationState,
+    stakingProvider: string,
+    stake: StakeData | undefined
+  ) => {
+    const authData = appState.stakingProviders.data[stakingProvider] || {}
+    const minAuth = appState.parameters.data.minimumAuthorization
+    return {
+      ...authData,
+      isAuthorized: BigNumber.from(authData?.authorizedStake || "0").gte(
+        BigNumber.from(minAuth || 0)
+      ),
+      percentage: calculatePercenteage(
+        authData?.authorizedStake,
+        stake?.totalInTStake
+      ),
+    }
+  }
+)
diff --git a/src/store/staking-applications/slice.ts b/src/store/staking-applications/slice.ts
new file mode 100644
index 000000000..c1126c46c
--- /dev/null
+++ b/src/store/staking-applications/slice.ts
@@ -0,0 +1,156 @@
+import { createSlice, PayloadAction } from "@reduxjs/toolkit"
+import {
+  StakingProviderAppInfo,
+  AuthorizationParameters,
+} from "../../threshold-ts/applications"
+import { FetchingState } from "../../types"
+import { startAppListening } from "../listener"
+import { setStakes } from "../staking"
+import {
+  getSupportedAppsStakingProvidersData,
+  getSupportedAppsEffect,
+} from "./effects"
+
+type StakingApplicationDataByStakingProvider = {
+  [stakingProvider: string]: StakingProviderAppInfo<string>
+}
+
+export type StakingApplicationState = {
+  parameters: FetchingState<AuthorizationParameters<string>>
+  stakingProviders: FetchingState<StakingApplicationDataByStakingProvider>
+}
+
+export interface StakingApplicationsState {
+  tbtc: StakingApplicationState
+  randomBeacon: StakingApplicationState
+}
+
+export type StakingAppName = "tbtc" | "randomBeacon"
+
+export const stakingApplicationsSlice = createSlice({
+  name: "staking-applications",
+  initialState: {
+    tbtc: {
+      parameters: {
+        isFetching: false,
+        error: "",
+        data: {
+          authorizationDecreaseChangePeriod: "0",
+          minimumAuthorization: "0",
+          authorizationDecreaseDelay: "0",
+        },
+      },
+      stakingProviders: {
+        isFetching: false,
+        error: "",
+        data: {},
+      },
+    },
+    randomBeacon: {
+      parameters: {
+        isFetching: false,
+        error: "",
+        data: {
+          authorizationDecreaseChangePeriod: "0",
+          minimumAuthorization: "0",
+          authorizationDecreaseDelay: "0",
+        },
+      },
+      stakingProviders: {
+        isFetching: false,
+        error: "",
+        data: {},
+      },
+    },
+  } as StakingApplicationsState,
+  reducers: {
+    getSupportedApps: (state: StakingApplicationsState, action) => {},
+    setAppParameters: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{
+        appName: StakingAppName
+        parameters: AuthorizationParameters<string>
+      }>
+    ) => {
+      const { appName, parameters } = action.payload
+      state[appName].parameters = {
+        data: { ...parameters },
+        isFetching: false,
+        error: "",
+      }
+    },
+    setAppParametersError: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{ appName: StakingAppName; error: string }>
+    ) => {
+      const { appName, error } = action.payload
+      state[appName].parameters.isFetching = false
+      state[appName].parameters.error = error
+    },
+    fetchingAppParameters: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{ appName: StakingAppName }>
+    ) => {
+      const { appName } = action.payload
+      state[appName].parameters.isFetching = true
+    },
+    setStakingProvidersAppData: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{
+        appName: StakingAppName
+        data: StakingApplicationDataByStakingProvider
+      }>
+    ) => {
+      const { appName, data } = action.payload
+      state[appName].stakingProviders = {
+        isFetching: false,
+        error: "",
+        data,
+      }
+    },
+    fetchingStakingProvidersAppData: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{
+        appName: StakingAppName
+      }>
+    ) => {
+      const { appName } = action.payload
+      state[appName].stakingProviders.isFetching = true
+    },
+    setStakingProvidersAppDataError: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{
+        appName: StakingAppName
+        error: string
+      }>
+    ) => {
+      const { appName, error } = action.payload
+      state[appName].stakingProviders.isFetching = false
+      state[appName].stakingProviders.error = error
+    },
+    authorizationIncreased: (
+      state: StakingApplicationsState,
+      action: PayloadAction<{
+        stakingProvider: string
+        toAmount: string
+        appName: StakingAppName
+      }>
+    ) => {
+      const { stakingProvider, toAmount, appName } = action.payload
+      if (state[appName].stakingProviders) {
+        state[appName].stakingProviders.data[stakingProvider].authorizedStake =
+          toAmount
+      }
+    },
+  },
+})
+
+startAppListening({
+  actionCreator: stakingApplicationsSlice.actions.getSupportedApps,
+  effect: getSupportedAppsEffect,
+})
+
+startAppListening({
+  actionCreator: setStakes,
+  effect: getSupportedAppsStakingProvidersData,
+})
diff --git a/src/threshold-ts/applications/__tests__/application.test.ts b/src/threshold-ts/applications/__tests__/application.test.ts
index 014861c52..2041cc0c2 100644
--- a/src/threshold-ts/applications/__tests__/application.test.ts
+++ b/src/threshold-ts/applications/__tests__/application.test.ts
@@ -1,4 +1,9 @@
-import { ContractInterface, BigNumber, providers } from "ethers"
+import {
+  ContractInterface,
+  BigNumber,
+  providers,
+  ContractTransaction,
+} from "ethers"
 import { AddressZero, getContract } from "../../utils"
 import { Application, IApplication } from ".."
 import { IStaking } from "../../staking"
@@ -15,6 +20,7 @@ describe("Application test", () => {
   const amount = BigNumber.from("123")
   const time = BigNumber.from("456")
   const address = AddressZero
+  const account = "0xE775aE21E40d34f01A5C0E1Db9FB3e637D768596"
   const abi: ContractInterface = []
   const stakingProvider = "0x486b0ee2eed761f069f327034eb2ae5e07580bf3"
   const mockedEthereumProvider = {} as providers.Provider
@@ -38,6 +44,7 @@ describe("Application test", () => {
   beforeEach(() => {
     staking = {
       authorizedStake: jest.fn(),
+      increaseAuthorization: jest.fn(),
       stakingContract: mockStakingContract,
     } as unknown as IStaking
     ;(getContract as jest.Mock).mockImplementation(() => mockAppContract)
@@ -46,6 +53,7 @@ describe("Application test", () => {
       abi,
       providerOrSigner: mockedEthereumProvider,
       chainId: "1",
+      account,
     })
   })
 
@@ -53,7 +61,8 @@ describe("Application test", () => {
     expect(getContract).toHaveBeenCalledWith(
       address,
       abi,
-      mockedEthereumProvider
+      mockedEthereumProvider,
+      account
     )
     expect(application.address).toEqual(address)
     expect(application.contract).toEqual(mockAppContract)
@@ -219,4 +228,23 @@ describe("Application test", () => {
       remainingAuthorizationDecreaseDelay,
     })
   })
+
+  test("should trigger the increase authorization transaction", async () => {
+    const tx = {} as ContractTransaction
+    const spyOnStaking = jest
+      .spyOn(staking, "increaseAuthorization")
+      .mockResolvedValue(tx)
+
+    const result = await application.increaseAuthorization(
+      stakingProvider,
+      amount
+    )
+
+    expect(spyOnStaking).toHaveBeenCalledWith(
+      stakingProvider,
+      application.address,
+      amount
+    )
+    expect(result).toEqual(tx)
+  })
 })
diff --git a/src/threshold-ts/applications/index.ts b/src/threshold-ts/applications/index.ts
index c6da4aea7..836bfd868 100644
--- a/src/threshold-ts/applications/index.ts
+++ b/src/threshold-ts/applications/index.ts
@@ -1,22 +1,30 @@
-import { BigNumber, Contract, ContractInterface } from "ethers"
+import {
+  BigNumber,
+  BigNumberish,
+  Contract,
+  ContractInterface,
+  ContractTransaction,
+} from "ethers"
 import { getContract, isAddress, isAddressZero } from "../utils"
 import { IStaking } from "../staking"
 import { EthereumConfig } from "../types"
 import { IMulticall, ContractCall } from "../multicall"
 
-export interface AuthorizationParameters {
+export interface AuthorizationParameters<
+  NumberType extends BigNumberish = BigNumber
+> {
   /**
    * The minimum authorization amount required so that operator can participate
    * in the random beacon. This amount is required to execute slashing for
    * providing a malicious DKG result or when a relay entry times out.
    */
-  minimumAuthorization: BigNumber
+  minimumAuthorization: NumberType
   /**
    * Delay in seconds that needs to pass between the time authorization decrease
    * is requested and the time that request gets approved. Protects against
    * free-riders earning rewards and not being active in the network.
    */
-  authorizationDecreaseDelay: BigNumber
+  authorizationDecreaseDelay: NumberType
   /**
    * Authorization decrease change period in seconds. It is the time, before
    * authorization decrease delay end, during which the pending authorization
@@ -25,22 +33,24 @@ export interface AuthorizationParameters {
    * `authorizationDecreaseDelay` ends. If set to value equal
    * `authorizationDecreaseDelay`, request can always be overwritten.
    */
-  authorizationDecreaseChangePeriod: BigNumber
+  authorizationDecreaseChangePeriod: NumberType
 }
 
-export interface StakingProviderAppInfo {
+export interface StakingProviderAppInfo<
+  NumberType extends BigNumberish = BigNumber
+> {
   /**
    * Authorized stake amount of the staking provider.
    */
-  authorizedStake: BigNumber
+  authorizedStake: NumberType
   /**
    * Amount being deauthorized for the staking provider.
    */
-  pendingAuthorizationDecrease: BigNumber
+  pendingAuthorizationDecrease: NumberType
   /**
    * Time in seconds until the deauthorization can be completed.
    */
-  remainingAuthorizationDecreaseDelay: BigNumber
+  remainingAuthorizationDecreaseDelay: NumberType
 }
 
 /**
@@ -120,6 +130,19 @@ export interface IApplication {
   getStakingProviderAppInfo(
     stakingProvider: string
   ): Promise<StakingProviderAppInfo>
+
+  /**
+   * Increases the authorization of the given staking provider for the
+   * application by the given amount. Can only be called by the given staking
+   * provider’s authorizer.
+   * @param stakingProvider Staking provider address.
+   * @param amount Amount to authrozie.
+   * @returns Ethers `ContractTransaction` instance.
+   */
+  increaseAuthorization(
+    stakingProvider: string,
+    amount: BigNumberish
+  ): Promise<ContractTransaction>
 }
 
 export class Application implements IApplication {
@@ -132,44 +155,44 @@ export class Application implements IApplication {
     multicall: IMulticall,
     config: EthereumConfig & { address: string; abi: ContractInterface }
   ) {
-    const { address, abi, providerOrSigner } = config
-    this._application = getContract(address, abi, providerOrSigner)
+    const { address, abi, providerOrSigner, account } = config
+    this._application = getContract(address, abi, providerOrSigner, account)
     this._staking = staking
     this._multicall = multicall
   }
 
-  async authorizedStake(stakingProvider: string): Promise<BigNumber> {
+  authorizedStake = async (stakingProvider: string): Promise<BigNumber> => {
     return await this._staking.authorizedStake(
       stakingProvider,
       this._application.address
     )
   }
 
-  async minimumAuthorization(): Promise<BigNumber> {
+  minimumAuthorization = async (): Promise<BigNumber> => {
     return await this._application.minimumAuthorization()
   }
 
-  async pendingAuthorizationDecrease(
+  pendingAuthorizationDecrease = async (
     stakingProvider: string
-  ): Promise<BigNumber> {
+  ): Promise<BigNumber> => {
     return await this._application.pendingAuthorizationDecrease(stakingProvider)
   }
 
-  async remainingAuthorizationDecreaseDelay(
+  remainingAuthorizationDecreaseDelay = async (
     stakingProvider: string
-  ): Promise<BigNumber> {
+  ): Promise<BigNumber> => {
     return await this._application.remainingAuthorizationDecreaseDelay(
       stakingProvider
     )
   }
 
-  async authorizationDecreaseDelay(): Promise<BigNumber> {
+  authorizationDecreaseDelay = async (): Promise<BigNumber> => {
     const { authorizationDecreaseDelay } =
       await this._application.authorizationParameters()
     return authorizationDecreaseDelay
   }
 
-  async authorizationParameters(): Promise<any> {
+  authorizationParameters = async (): Promise<any> => {
     const {
       minimumAuthorization,
       authorizationDecreaseDelay,
@@ -183,7 +206,7 @@ export class Application implements IApplication {
     }
   }
 
-  async getStakingProviderAppInfo(stakingProvider: string): Promise<any> {
+  getStakingProviderAppInfo = async (stakingProvider: string): Promise<any> => {
     const calls: ContractCall[] = [
       {
         interface: this._staking.stakingContract.interface,
@@ -218,7 +241,7 @@ export class Application implements IApplication {
     }
   }
 
-  async isEligibleForRewards(stakingProvider: string): Promise<boolean> {
+  isEligibleForRewards = async (stakingProvider: string): Promise<boolean> => {
     const operator = await this._application.stakingProviderToOperator(
       stakingProvider
     )
@@ -238,4 +261,15 @@ export class Application implements IApplication {
   get contract() {
     return this._application
   }
+
+  increaseAuthorization = async (
+    stakingProvider: string,
+    amount: BigNumberish
+  ): Promise<ContractTransaction> => {
+    return this._staking.increaseAuthorization(
+      stakingProvider,
+      this.address,
+      amount
+    )
+  }
 }
diff --git a/src/threshold-ts/index.ts b/src/threshold-ts/index.ts
index 67cb75f7d..e6df28131 100644
--- a/src/threshold-ts/index.ts
+++ b/src/threshold-ts/index.ts
@@ -4,11 +4,15 @@ import { IStaking, Staking } from "./staking"
 import { ThresholdConfig } from "./types"
 
 export class Threshold {
-  multicall: IMulticall
-  staking: IStaking
-  multiAppStaking: MultiAppStaking
+  multicall!: IMulticall
+  staking!: IStaking
+  multiAppStaking!: MultiAppStaking
 
   constructor(config: ThresholdConfig) {
+    this._initialize(config)
+  }
+
+  private _initialize = (config: ThresholdConfig) => {
     this.multicall = new Multicall(config.ethereum)
     this.staking = new Staking(config.ethereum)
     this.multiAppStaking = new MultiAppStaking(
@@ -17,4 +21,8 @@ export class Threshold {
       config.ethereum
     )
   }
+
+  updateConfig = (config: ThresholdConfig) => {
+    this._initialize(config)
+  }
 }
diff --git a/src/threshold-ts/multicall/__test__/multicall.test.ts b/src/threshold-ts/multicall/__test__/multicall.test.ts
index a3858e967..8dd4a3a17 100644
--- a/src/threshold-ts/multicall/__test__/multicall.test.ts
+++ b/src/threshold-ts/multicall/__test__/multicall.test.ts
@@ -18,7 +18,11 @@ describe("Multicall test", () => {
   let multicall: IMulticall
   const mockMulticallContract = { aggregate: jest.fn() }
   const mockProvider = {} as providers.Provider
-  const config = { chainId: 1, providerOrSigner: mockProvider }
+  const config = {
+    chainId: 1,
+    providerOrSigner: mockProvider,
+    account: "0xE775aE21E40d34f01A5C0E1Db9FB3e637D768596",
+  }
 
   beforeEach(() => {
     ;(getContract as jest.Mock).mockImplementation(() => mockMulticallContract)
@@ -29,7 +33,8 @@ describe("Multicall test", () => {
     expect(getContract).toHaveBeenCalledWith(
       MULTICALL_ADDRESSESS[config.chainId],
       MULTICALL_ABI,
-      config.providerOrSigner
+      config.providerOrSigner,
+      config.account
     )
     expect(multicall).toBeInstanceOf(Multicall)
     expect(multicall.aggregate).toBeDefined()
diff --git a/src/threshold-ts/multicall/index.ts b/src/threshold-ts/multicall/index.ts
index c26b4f4fd..550f44039 100644
--- a/src/threshold-ts/multicall/index.ts
+++ b/src/threshold-ts/multicall/index.ts
@@ -48,7 +48,8 @@ export class Multicall implements IMulticall {
     this._multicall = getContract(
       address,
       MULTICALL_ABI,
-      config.providerOrSigner
+      config.providerOrSigner,
+      config.account
     )
   }
 
diff --git a/src/threshold-ts/staking/__test__/staking.test.ts b/src/threshold-ts/staking/__test__/staking.test.ts
new file mode 100644
index 000000000..ea91f4ef7
--- /dev/null
+++ b/src/threshold-ts/staking/__test__/staking.test.ts
@@ -0,0 +1,82 @@
+import { BigNumber, ContractTransaction, providers } from "ethers"
+import TokenStaking from "@threshold-network/solidity-contracts/artifacts/TokenStaking.json"
+import { IStaking, Staking } from ".."
+import { AddressZero, getContract } from "../../utils"
+
+jest.mock("../../utils", () => ({
+  ...(jest.requireActual("../../utils") as {}),
+  getContract: jest.fn(),
+}))
+jest.mock(
+  "@threshold-network/solidity-contracts/artifacts/TokenStaking.json",
+  () => ({
+    address: "0x6A55B762689Ba514569E565E439699aBC731f156",
+    abi: [],
+  })
+)
+
+describe("Staking test", () => {
+  let staking: IStaking
+  const mockStakingContract = {
+    interface: {},
+    address: TokenStaking.address,
+    authorizedStake: jest.fn(),
+    increaseAuthorization: jest.fn(),
+  }
+  const stakingProvider = "0x486b0ee2eed761f069f327034eb2ae5e07580bf3"
+  const application = "0xE775aE21E40d34f01A5C0E1Db9FB3e637D768596"
+  const mockedEthereumProvider = {} as providers.Provider
+  const ethConfig = {
+    providerOrSigner: mockedEthereumProvider,
+    chainId: 1,
+    account: AddressZero,
+  }
+
+  beforeEach(() => {
+    ;(getContract as jest.Mock).mockImplementation(() => mockStakingContract)
+    staking = new Staking(ethConfig)
+  })
+
+  test("should create the staking instance correctly", () => {
+    expect(getContract).toHaveBeenCalledWith(
+      TokenStaking.address,
+      TokenStaking.abi,
+      ethConfig.providerOrSigner,
+      ethConfig.account
+    )
+    expect(staking.stakingContract).toEqual(mockStakingContract)
+  })
+
+  test("should return authrozied stake for an application and staking provider", async () => {
+    const mockResult = BigNumber.from("100")
+    mockStakingContract.authorizedStake.mockResolvedValue(mockResult)
+
+    const result = await staking.authorizedStake(stakingProvider, application)
+
+    expect(mockStakingContract.authorizedStake).toHaveBeenCalledWith(
+      stakingProvider,
+      application
+    )
+    expect(result).toEqual(mockResult)
+  })
+
+  test("should return authrozied stake for an application and staking provider", async () => {
+    const tx = {} as ContractTransaction
+    const amount = BigNumber.from("100")
+
+    mockStakingContract.increaseAuthorization.mockResolvedValue(tx)
+
+    const result = await staking.increaseAuthorization(
+      stakingProvider,
+      application,
+      amount
+    )
+
+    expect(mockStakingContract.increaseAuthorization).toHaveBeenCalledWith(
+      stakingProvider,
+      application,
+      amount
+    )
+    expect(result).toEqual(tx)
+  })
+})
diff --git a/src/threshold-ts/staking/index.ts b/src/threshold-ts/staking/index.ts
index 68cfdb434..900f1e5e0 100644
--- a/src/threshold-ts/staking/index.ts
+++ b/src/threshold-ts/staking/index.ts
@@ -1,15 +1,34 @@
 import TokenStaking from "@threshold-network/solidity-contracts/artifacts/TokenStaking.json"
-import { BigNumber, Contract } from "ethers"
+import { BigNumber, BigNumberish, Contract, ContractTransaction } from "ethers"
 import { EthereumConfig } from "../types"
 import { getContract } from "../utils"
 
 export interface IStaking {
   stakingContract: Contract
+  /**
+   * Returns the authorized stake amount of the staking provider for the application.
+   * @param stakingProvider Staking provider address.
+   * @param application Application address.
+   * @returns Authorized stake amount.
+   */
   authorizedStake(
     stakingProvider: string,
     application: string
   ): Promise<BigNumber>
-
+  /**
+   * Increases the authorization of the given staking provider for the given
+   * application by the given amount. Can only be called by the given staking
+   * provider’s authorizer.
+   * @param stakingProvider Staking provider address.
+   * @param application Application address.
+   * @param amount Amount to authrozie.
+   * @returns Ethers `ContractTransaction` instance.
+   */
+  increaseAuthorization(
+    stakingProvider: string,
+    application: string,
+    amount: BigNumberish
+  ): Promise<ContractTransaction>
   // TODO: move other functions here eg fetching all owner stakes.
 }
 
@@ -20,7 +39,8 @@ export class Staking implements IStaking {
     this._staking = getContract(
       TokenStaking.address,
       TokenStaking.abi,
-      config.providerOrSigner
+      config.providerOrSigner,
+      config.account
     )
   }
 
@@ -34,4 +54,16 @@ export class Staking implements IStaking {
   get stakingContract() {
     return this._staking
   }
+
+  increaseAuthorization = async (
+    stakingProvider: string,
+    application: string,
+    amount: BigNumberish
+  ): Promise<ContractTransaction> => {
+    return await this._staking.increaseAuthorization(
+      stakingProvider,
+      application,
+      amount
+    )
+  }
 }
diff --git a/src/threshold-ts/types/index.ts b/src/threshold-ts/types/index.ts
index 7e4895d78..a7fc8b463 100644
--- a/src/threshold-ts/types/index.ts
+++ b/src/threshold-ts/types/index.ts
@@ -3,6 +3,7 @@ import { providers, Signer } from "ethers"
 export interface EthereumConfig {
   providerOrSigner: providers.Provider | Signer
   chainId: string | number
+  account?: string
 }
 
 export interface ThresholdConfig {
diff --git a/src/threshold-ts/utils/contract.ts b/src/threshold-ts/utils/contract.ts
index 955d9f5a9..4411589cc 100644
--- a/src/threshold-ts/utils/contract.ts
+++ b/src/threshold-ts/utils/contract.ts
@@ -1,9 +1,35 @@
+import { JsonRpcSigner, Web3Provider } from "@ethersproject/providers"
 import { Contract, ContractInterface, providers, Signer } from "ethers"
+import { getAddress, isAddressZero } from "./address"
+
+// account is not optional
+export function getSigner(
+  library: Web3Provider,
+  account: string
+): JsonRpcSigner {
+  return library.getSigner(account).connectUnchecked()
+}
+
+// account is optional
+function getProviderOrSigner(
+  library: Web3Provider,
+  account?: string
+): Web3Provider | JsonRpcSigner {
+  return account ? getSigner(library, account) : library
+}
 
 export const getContract = (
   address: string,
   abi: ContractInterface,
-  providerOrSigner: providers.Provider | Signer | undefined
+  providerOrSigner: providers.Provider | Signer | undefined,
+  account?: string
 ) => {
-  return new Contract(address, abi, providerOrSigner)
+  if (!getAddress(address) || isAddressZero(address)) {
+    throw Error(`Invalid 'address' parameter '${address}'.`)
+  }
+  return new Contract(
+    address,
+    abi,
+    getProviderOrSigner(providerOrSigner as any, account) as any
+  )
 }
diff --git a/src/types/index.ts b/src/types/index.ts
index c55a36e41..1c75125dd 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -7,3 +7,9 @@ export * from "./eth"
 export * from "./page"
 export * from "./rewards"
 export * from "./staking"
+
+export type FetchingState<DataType> = {
+  isFetching: boolean
+  error: string
+  data: DataType
+}
diff --git a/src/utils/getContract.ts b/src/utils/getContract.ts
index 08e082b9e..a34c680d2 100644
--- a/src/utils/getContract.ts
+++ b/src/utils/getContract.ts
@@ -1,41 +1,5 @@
-import { getAddress } from "@ethersproject/address"
-import { AddressZero } from "@ethersproject/constants"
-import { Contract } from "@ethersproject/contracts"
-import { JsonRpcSigner, Web3Provider } from "@ethersproject/providers"
-import { isAddressZero } from "../web3/utils"
-
-// account is not optional
-export function getSigner(
-  library: Web3Provider,
-  account: string
-): JsonRpcSigner {
-  return library.getSigner(account).connectUnchecked()
-}
-
-// account is optional
-function getProviderOrSigner(
-  library: Web3Provider,
-  account?: string
-): Web3Provider | JsonRpcSigner {
-  return account ? getSigner(library, account) : library
-}
-
-export function getContract(
-  address: string,
-  ABI: any,
-  library: Web3Provider,
-  account?: string
-): Contract {
-  if (!getAddress(address) || isAddressZero(address)) {
-    throw Error(`Invalid 'address' parameter '${address}'.`)
-  }
-
-  return new Contract(
-    address,
-    ABI,
-    getProviderOrSigner(library, account) as any
-  )
-}
+import { AddressZero } from "../web3/utils/address"
+export { getSigner, getContract } from "../threshold-ts/utils/contract"
 
 export function getContractAddressFromTruffleArtifact(
   truffleArtifact: { networks: { [chainID: string]: { address: string } } },
diff --git a/src/utils/getThresholdLib.ts b/src/utils/getThresholdLib.ts
new file mode 100644
index 000000000..62015a717
--- /dev/null
+++ b/src/utils/getThresholdLib.ts
@@ -0,0 +1,22 @@
+import { JsonRpcProvider, Provider } from "@ethersproject/providers"
+import { Signer } from "ethers"
+import { Threshold } from "../threshold-ts"
+import { EnvVariable } from "../enums"
+import { getEnvVariable, supportedChainId } from "../utils/getEnvVariable"
+
+export const getDefaultThresholdLibProvider = () => {
+  return new JsonRpcProvider(getEnvVariable(EnvVariable.ETH_HOSTNAME_HTTP))
+}
+
+export const getThresholdLib = (providerOrSigner?: Provider | Signer) => {
+  return new Threshold({
+    ethereum: {
+      chainId: supportedChainId,
+      providerOrSigner: providerOrSigner || getDefaultThresholdLibProvider(),
+    },
+  })
+}
+
+export const threshold = getThresholdLib(
+  new JsonRpcProvider(getEnvVariable(EnvVariable.ETH_HOSTNAME_HTTP))
+)
diff --git a/src/utils/percentage.ts b/src/utils/percentage.ts
index 2f6e5b560..873f9f152 100644
--- a/src/utils/percentage.ts
+++ b/src/utils/percentage.ts
@@ -1,3 +1,23 @@
+import { BigNumber, BigNumberish, FixedNumber } from "ethers"
+
+export const calculatePercenteage = (
+  amount: BigNumberish | undefined,
+  totalAmount: BigNumberish | undefined
+) => {
+  if (
+    !amount ||
+    BigNumber.from(amount).isZero() ||
+    !totalAmount ||
+    BigNumber.from(totalAmount).isZero()
+  )
+    return 0
+
+  return FixedNumber.fromString(amount.toString())
+    .divUnsafe(FixedNumber.fromString(totalAmount.toString()))
+    .mulUnsafe(FixedNumber.fromString("100"))
+    .toUnsafeFloat()
+}
+
 export const formatPercentage = (
   percentage: number,
   decimalPlaces: number = 0,