diff --git a/src/assets/pic/collective-logo.jpg b/src/assets/pic/collective-logo.jpg
new file mode 100644
index 0000000..7a511f2
Binary files /dev/null and b/src/assets/pic/collective-logo.jpg differ
diff --git a/src/assets/pic/rif-logo.png b/src/assets/pic/rif-logo.png
new file mode 100644
index 0000000..3362d21
Binary files /dev/null and b/src/assets/pic/rif-logo.png differ
diff --git a/src/assets/pic/rootstock.png b/src/assets/pic/rootstock.png
new file mode 100644
index 0000000..093b18d
Binary files /dev/null and b/src/assets/pic/rootstock.png differ
diff --git a/src/components/account-select/index.vue b/src/components/account-select/index.vue
index a5f3cfe..9d1c5d3 100644
--- a/src/components/account-select/index.vue
+++ b/src/components/account-select/index.vue
@@ -1,13 +1,13 @@
 <template>
   <div class="account-select" v-if="account">
     <a ref="toggle" class="account-select__block" @click="toggleAction" href="javascript:void(0)">
-      <img :src="wallet.wallet.value?.adapter.icon" />
+      <img :src="walletIcon" />
       <span>{{ $filters.replaceWithEllipsis(account.address, 4, 4) }}</span>
       <arrow-down />
     </a>
     <div v-show="isOpen" ref="dropdown" class="account-select__dropdown">
       <div class="account-select__info">
-        <img :src="wallet.wallet.value?.adapter.icon" />
+        <img :src="walletIcon" />
         <span>{{ $filters.replaceWithEllipsis(account.address, 4, 4) }}</span>
         <a class="account-select__info-action" @click="onCopyClicked" href="javascript:void(0)">
           <copy-icon />
@@ -16,8 +16,20 @@
           <link-icon />
         </a>
       </div>
+      <div v-if="isRootstock" class="account-select__amount">
+       {{rbtcBalance <= MIN_BALANCE_EVM ? '<': ''  }} {{ $filters.cryptoCurrencyFormat(rbtcBalance) }} <span>RBTC</span>
+      </div>
       <div class="account-select__amount">
-        {{ $filters.cryptoCurrencyFormat(walletBalance) }} <span>sol</span>
+        <template v-if="isRootstock">
+          {{ Number(walletBalance || 0).toFixed(0) }}&nbsp;
+        </template>
+        <template v-else>
+          {{ $filters.cryptoCurrencyFormat(walletBalance) }}
+        </template>
+        <span>{{ balanceSymbol }}</span>
+      </div>
+      <div v-if="isRootstock" class="account-select__amount">
+        {{ Number(usdrifBalance || 0).toFixed(0) }} <span>USDRIF</span>
       </div>
       <a @click="disconnectAction" class="account-select__disconnect" href="javascript:void(0)">
         <logout-icon />
@@ -29,7 +41,7 @@
 
 <script setup lang="ts">
 import { useStore } from "vuex";
-import { PropType, ref, computed } from "vue";
+import { PropType, ref, computed, watch } from "vue";
 import { Account } from "@/types/account";
 import ArrowDown from "@/icons/common/arrow-down.vue";
 import { onClickOutside } from "@vueuse/core";
@@ -37,17 +49,18 @@ import CopyIcon from "@/icons/common/copy-icon.vue";
 import LinkIcon from "@/icons/common/link-icon.vue";
 import LogoutIcon from "@/icons/common/logout-icon.vue";
 import { SharedTypes } from "@/store/shared/consts";
-import { copyToClipboard, openSolscanExplorerAddress } from "@/utils/browser";
+import { copyToClipboard, openExplorerAddress } from "@/utils/browser";
 import { useWallet } from "solana-wallets-vue";
+import { Chains } from "@/core/interfaces";
+import { BASE_TOKENS, MIN_BALANCE_EVM, ROOTSTOCK_USDRIF_TOKEN_ADDRESS } from "@/core/constants/index";
+import EvmWalletService from "@/core/services/evmWalletService";
 
 const wallet = useWallet();
 const isOpen = ref<boolean>(false);
 const dropdown = ref(null);
 const toggle = ref(null);
 const store = useStore();
-
-const walletBalance = computed(() => store.getters[SharedTypes.WALLET_BALANCE_GETTER]);
-const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const evmWalletService = EvmWalletService.getInstance();
 
 const props = defineProps({
   account: {
@@ -56,6 +69,18 @@ const props = defineProps({
   },
 });
 
+const walletBalance = computed(() => store.getters[SharedTypes.WALLET_BALANCE_GETTER]);
+const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const walletIcon = computed(() => props.account?.image ?? wallet.wallet.value?.adapter.icon ?? "");
+const isRootstock = computed(() => activeChain.value === Chains.ROOTSTOCK);
+const rbtcBalance = ref<number>(0);
+const usdrifBalance = ref<number>(0);
+const balanceSymbol = computed(() => {
+  const chain = activeChain.value as Chains;
+  return BASE_TOKENS[chain]?.symbol?.toUpperCase?.() ?? "";
+});
+
 const emit = defineEmits(["disconnect"]);
 
 const toggleAction = () => {
@@ -73,9 +98,33 @@ const onCopyClicked = () => {
 }
 
 const onLinkClicked = () => {
-  openSolscanExplorerAddress(props.account.address, network.value);
+  openExplorerAddress(props.account.address, activeChain.value as Chains, network.value);
 }
 
+watch(
+  [() => props.account?.address, activeChain],
+  async ([address, chain]) => {
+    if (!address || chain !== Chains.ROOTSTOCK) {
+      rbtcBalance.value = 0;
+      usdrifBalance.value = 0;
+      return;
+    }
+
+    try {
+      const [nextRbtcBalance, nextUsdrifBalance] = await Promise.all([
+        evmWalletService.loadBalance(address),
+        evmWalletService.loadTokenBalance(address, ROOTSTOCK_USDRIF_TOKEN_ADDRESS),
+      ]);
+      rbtcBalance.value = nextRbtcBalance;
+      usdrifBalance.value = nextUsdrifBalance;
+    } catch {
+      rbtcBalance.value = 0;
+      usdrifBalance.value = 0;
+    }
+  },
+  { immediate: true }
+);
+
 onClickOutside(
   dropdown,
   () => {
@@ -168,6 +217,11 @@ onClickOutside(
     span {
       text-transform: uppercase;
     }
+
+    &--secondary {
+      padding-top: 0;
+      color: @secondaryLabel;
+    }
   }
 
   &__disconnect {
diff --git a/src/components/amount-input/index.vue b/src/components/amount-input/index.vue
index f72df53..f5b0dfb 100644
--- a/src/components/amount-input/index.vue
+++ b/src/components/amount-input/index.vue
@@ -10,7 +10,7 @@
       :small="true"
     />
     <div class="amount-input__balance" :class="{ error: !hasEnoughBalance }">
-      Balance: {{ maxValue }}
+      Balance: {{ maxValueDisplay }}
     </div>
     <div class="amount-input__wrapper">
       <input
@@ -124,6 +124,12 @@ const amountValue = computed({
 
 const prices = computed(() => store.getters[SharedTypes.PRICE_GETTER]);
 const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const maxValueDisplay = computed(() => {
+  if (activeChain.value === "rootstock") {
+    return Number(props.maxValue || 0).toFixed(2);
+  }
+  return props.maxValue;
+});
 const amountUsd = computed(() => {
   const value = parseFloat(amountValue.value || "0");
   const price = prices.value?.[BASE_TOKENS[activeChain.value].symbol] || 0;
diff --git a/src/components/app-header/index.vue b/src/components/app-header/index.vue
index 0de3ce8..97883c8 100644
--- a/src/components/app-header/index.vue
+++ b/src/components/app-header/index.vue
@@ -17,23 +17,21 @@
             <span>Get Enkrypt</span>
           </a>
 
-          <!--
           <select-list
             v-if="!isToggleMenu"
-            :select="network"
-            :items="[chainsData[Chains.SOLANA]]"
+            :select="currentChainOption"
+            :items="chainOptions"
             :is-minify="true"
             :is-list-image="true"
             @update:select="selectNetworkAction"
           />
-          -->
 
           <account-select
-            v-if="wallet.connected.value && !isToggleMenu"
+            v-if="isWalletConnected && !isToggleMenu"
             :account="walletAccount"
             @disconnect="disconnectWallet"
           ></account-select>
-          <a v-else-if="!isToggleMenu && !wallet.connected.value" class="header__connect" @click="openWalletModal" href="javascript:void(0)">
+          <a v-else-if="!isToggleMenu" class="header__connect" @click="connectWallet" href="javascript:void(0)">
             Connect
           </a>
         </div>
@@ -70,13 +68,22 @@ const store = useStore();
 const router = useRouter();
 const isScroll = ref<boolean>(false);
 const wallet = useWallet();
-const network = ref<ChainDataItem>(chainsData[Chains.SOLANA]);
 const walletAccount = computed(() => store.getters[SharedTypes.WALLET_ACCOUNT_GETTER]);
 const isWalletModalOpen = computed(() => store.getters[SharedTypes.IS_CONNECT_MODAL_VISIBLE_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const isWalletConnected = computed(() => store.getters[SharedTypes.IS_WALLET_CONNECTED_GETTER]);
+const chainOptions = computed<ChainDataItem[]>(() => [
+  chainsData[Chains.SOLANA],
+  chainsData[Chains.ROOTSTOCK],
+]);
+const currentChainOption = computed<ChainDataItem>(() => chainsData[activeChain.value]);
 
 watch(
   () => wallet.publicKey?.value,
   (newVal, oldVal) => {
+    if (activeChain.value !== Chains.SOLANA) {
+      return;
+    }
     if (newVal) {
       if (oldVal && newVal.toString() !== oldVal.toString()) {
         store.dispatch(SharedTypes.DISCONNECT_WALLET_ACTION);
@@ -89,9 +96,13 @@ watch(
   { immediate: true }
 );
 
-const openWalletModal = () => {
+const connectWallet = async () => {
   trackButtonsEvents(ButtonsActionEventType.MainScreenConnectButtonClicked);
-  store.dispatch(SharedTypes.CONNECT_MODAL_ACTION, true);
+  if (activeChain.value === Chains.SOLANA) {
+    store.dispatch(SharedTypes.CONNECT_MODAL_ACTION, true);
+  } else {
+    await store.dispatch(SharedTypes.CONNECT_EVM_WALLET_ACTION);
+  }
 };
 
 const updateWalletModalVisibility = (visible: boolean) => {
@@ -101,10 +112,13 @@ const updateWalletModalVisibility = (visible: boolean) => {
 const disconnectWallet = async () => {
   trackButtonsEvents(ButtonsActionEventType.MainScreenDisconnectButtonClicked);
   try {
-    if (wallet.connected.value) {
+    if (activeChain.value === Chains.SOLANA && wallet.connected.value) {
       await store.dispatch(SharedTypes.DISCONNECT_WALLET_ACTION);
       await wallet.disconnect();
       router.push('/');
+    } else if (activeChain.value === Chains.ROOTSTOCK) {
+      await store.dispatch(SharedTypes.DISCONNECT_WALLET_ACTION);
+      router.push('/');
     }
   } catch (err) {
     console.error('Failed to disconnect:', err);
@@ -140,8 +154,17 @@ const onScroll = () => {
   }
 };
 
-const selectNetworkAction = (item: ChainDataItem) => {
-  network.value = item;
+const selectNetworkAction = async (item: ChainDataItem) => {
+  if (item.id === activeChain.value) {
+    return;
+  }
+
+  if (activeChain.value === Chains.SOLANA && wallet.connected.value) {
+    await store.dispatch(SharedTypes.DISCONNECT_WALLET_ACTION);
+    await wallet.disconnect();
+  }
+
+  await store.dispatch(SharedTypes.SWITCH_CHAIN_ACTION, item.id as Chains);
 };
 
 const toggleMenu = () => {
diff --git a/src/components/app-menu/index.vue b/src/components/app-menu/index.vue
index 1770843..8199e52 100644
--- a/src/components/app-menu/index.vue
+++ b/src/components/app-menu/index.vue
@@ -18,11 +18,19 @@
         >
           <span>Stake Solana</span>
         </router-link>
+        <router-link 
+          :to="{ name: 'stake' }" 
+          class="stake"
+          :class="{ disabled: !isStakeRootstockEnabled }"
+          :disabled="!isStakeRootstockEnabled"
+        >
+          <span>Stake Rootstock</span>
+        </router-link>
         <router-link 
           :to="{ name: 'portfolio' }" 
           class="portfolio"
-          :class="{ disabled: !wallet.connected.value }"
-          :disabled="!wallet.connected.value"
+          :class="{ disabled: !isPortfolioEnabled }"
+          :disabled="!isPortfolioEnabled"
         >
           <portfolio-icon />
           <span>My staking portfolio</span>
@@ -61,10 +69,53 @@
 import HomeIcon from "@/icons/menu/home-icon.vue";
 import PortfolioIcon from "@/icons/menu/portfolio-icon.vue";
 import BuyIcon from "@/icons/menu/buy-icon.vue";
+import { computed, ref, watch } from "vue";
+import { useStore } from "vuex";
 import { useWallet } from "solana-wallets-vue";
 import { openContactSupport } from "@/utils/browser";
+import { SharedTypes } from "@/store/shared/consts";
+import { Chains } from "@/core/interfaces";
+import { ROOTSTOCK_STRIF_TOKEN_ADDRESS, STRIF_TOKEN_ABI } from "@/core/constants";
+import EvmWalletService from "@/core/services/evmWalletService";
+import { ethers } from "ethers";
 
 const wallet = useWallet();
+const store = useStore();
+const evmWalletService = EvmWalletService.getInstance();
+const rootstockStakedBalance = ref(0);
+const chain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const account = computed(() => store.getters[SharedTypes.WALLET_ACCOUNT_GETTER]);
+const rootstockBalance = computed(() => store.getters[SharedTypes.WALLET_BALANCE_GETTER]);
+const isPortfolioEnabled = computed(() => {
+  if (chain.value === Chains.ROOTSTOCK) {
+    return rootstockStakedBalance.value > 0;
+  }
+  return wallet.connected.value;
+});
+const isStakeRootstockEnabled = computed(() => {
+  return chain.value === Chains.ROOTSTOCK && !!account.value?.address && rootstockBalance.value > 0;
+});
+
+watch([chain, account], async () => {
+  if (chain.value !== Chains.ROOTSTOCK || !account.value?.address) {
+    rootstockStakedBalance.value = 0;
+    return;
+  }
+
+  try {
+    const provider = evmWalletService.getRpcProvider();
+    if (!provider) {
+      rootstockStakedBalance.value = 0;
+      return;
+    }
+
+    const stRifContract = new ethers.Contract(ROOTSTOCK_STRIF_TOKEN_ADDRESS, STRIF_TOKEN_ABI, provider);
+    const balance = await stRifContract.balanceOf(account.value.address);
+    rootstockStakedBalance.value = Number(ethers.utils.formatEther(balance));
+  } catch {
+    rootstockStakedBalance.value = 0;
+  }
+}, { immediate: true });
 
 defineProps({
   isToggleMenu: {
diff --git a/src/core/api/price.ts b/src/core/api/price.ts
index 5171561..2ed3340 100644
--- a/src/core/api/price.ts
+++ b/src/core/api/price.ts
@@ -1,8 +1,8 @@
 import { makeRequest } from "@/utils/request";
-import { SolanaPriceResponse, SolanaPriceRequest } from "../interfaces/price";
+import { TokenMarketDataResponse, TokenMarketDataRequest } from "../interfaces/price";
 
-export async function getSolanaPrice(): Promise<SolanaPriceResponse> {
-  return makeRequest<SolanaPriceRequest, SolanaPriceResponse>({
+export async function getTokenMarketData(tokenId: string): Promise<TokenMarketDataResponse> {
+  return makeRequest<TokenMarketDataRequest, TokenMarketDataResponse>({
     route: "",
     externalLink: `https://api-v3.ethvm.dev/`,
     method: "POST",
@@ -10,7 +10,7 @@ export async function getSolanaPrice(): Promise<SolanaPriceResponse> {
       operationName: null,
       variables: {},
       query:
-        '{\n  getCoinGeckoTokenMarketDataByIds(coinGeckoTokenIds: ["solana"]) {\n    id\n    symbol\n    name\n    image\n    market_cap\n    market_cap_rank\n    high_24h\n    low_24h\n    price_change_24h\n    price_change_percentage_24h\n    sparkline_in_24h {\n      price\n    }\n    price_change_percentage_24h_in_currency\n    current_price\n  }\n}\n',
+        `{\n  getCoinGeckoTokenMarketDataByIds(coinGeckoTokenIds: ["${tokenId}"]) {\n    id\n    symbol\n    name\n    image\n    market_cap\n    market_cap_rank\n    high_24h\n    low_24h\n    price_change_24h\n    price_change_percentage_24h\n    sparkline_in_24h {\n      price\n    }\n    price_change_percentage_24h_in_currency\n    current_price\n  }\n}\n`,
     },
   });
 }
diff --git a/src/core/api/staking.ts b/src/core/api/staking.ts
index 32bef8c..7ed65f2 100644
--- a/src/core/api/staking.ts
+++ b/src/core/api/staking.ts
@@ -15,6 +15,7 @@ import {
   GetValidatorSummaryResponse,
   GetDelegatorApyResponse,
   getDelegatorRewardsResponse,
+  RootstockAbiResponse,
 } from "@/core/interfaces";
 import { makeRequest } from "@/utils/request";
 import { P2P_VALIDATOR } from "@/core/constants"
@@ -142,3 +143,11 @@ export async function getDelegatorApy(
     method: "GET",
   });
 };
+
+export async function getRootstockAbi(): Promise<RootstockAbiResponse> {
+  return makeRequest<void, RootstockAbiResponse>({
+    route: ``,
+    externalLink: "https://metrics-api.rootstockcollective.xyz/api/rc-abi",
+    method: "GET",
+  });
+};
diff --git a/src/core/constants/index.ts b/src/core/constants/index.ts
index 4795651..dd99e33 100644
--- a/src/core/constants/index.ts
+++ b/src/core/constants/index.ts
@@ -10,6 +10,7 @@ export const WALLET_TYPES = {
 export const P2P_VALIDATOR = "FKsC411dik9ktS6xPADxs4Fk2SCENvAiuccQHLAPndvk";
 export const LAMPORTS_IN_SOL = 1_000_000_000;
 export const SOL_FEE = 5000;
+export const MIN_BALANCE_EVM = 0.00001;
 
 export const BASE_TOKENS: BaseTokens = {
   [Chains.SOLANA]: {
@@ -17,12 +18,21 @@ export const BASE_TOKENS: BaseTokens = {
     name: "Solana",
     image: require("@/assets/pic/solana.token.svg"),
     symbol: "sol",
+    coinGeckoId: "solana",
   },
   [Chains.ETHEREUM]: {
     id: 2,
     name: "Ethereum",
     image: require("@/assets/pic/ethereum.network.png"),
     symbol: "eth",
+    coinGeckoId: "ethereum",
+  },
+  [Chains.ROOTSTOCK]: {
+    id: 3,
+    name: "Rootstock",
+    image: require("@/assets/pic/rif-logo.png"),
+    symbol: "rif",
+    coinGeckoId: "rif-token",
   }
 };
 
@@ -31,6 +41,11 @@ export const chainsData: ChainData = {
     id: "solana",
     name: "Solana",
     image: require("@/assets/pic/solana.network.png"),
+  },
+  [Chains.ROOTSTOCK]: {
+    id: "rootstock",
+    name: "Rootstock",
+    image: require("@/assets/pic/rootstock.png"),
   }
 }
 
@@ -49,6 +64,62 @@ export const validators: {
         image: require("@/assets/pic/p2p.validator.svg"),
         address: "FKsC411dik9ktS6xPADxs4Fk2SCENvAiuccQHLAPndvk",
       }
+    },
+    [Chains.ROOTSTOCK]: {
+      apy: "",
+      fee: "",
+      validatorData: {
+        id: "rootstockcollective",
+        name: "RootstockCollective",
+        image: require("@/assets/pic/collective-logo.jpg"),
+        address: "0x0000000000000000000000000000000000000000",
+      }
     }
   }
 }
+
+export const ROOTSTOCK_RIF_TOKEN_ADDRESS = "0x2acc95758f8b5f583470ba265eb685a8f45fc9d5";
+export const ROOTSTOCK_STRIF_TOKEN_ADDRESS = "0x5db91e24bd32059584bbdb831a901f1199f3d459";
+export const ROOTSTOCK_RBTC_TOKEN_ADDRESS = "0xf7ab6cfaebbadfe8b5494022c4c6db776bd63b6b";
+export const ROOTSTOCK_BUILDER_REGISTRY_ADDRESS = "0x8cb62c58AC3D1253c6467537FDDc563857eD76cb";
+export const ROOTSTOCK_REWARD_DISTRIBUTOR_ADDRESS = "0x5603Ba40257e317e45BA13C3732819Af5E81a9A1";
+export const ROOTSTOCK_BACKER_MANAGER_ADDRESS = "0x7995C48D987941291d8008695A4133E557a11530";
+export const ROOTSTOCK_USDRIF_TOKEN_ADDRESS = "0x3a15461d8ae0f0fb5fa2629e9da7d66a794a6e37";
+
+export const RIF_TOKEN_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+];
+
+export const STRIF_TOKEN_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function depositAndDelegate(address to, uint256 value)",
+  "function withdrawTo(address account, uint256 value) returns (bool)",
+];
+
+export const ROOTSTOCK_BUILDER_REGISTRY_ABI = [
+  "function getGaugesLength() view returns (uint256)",
+  "function getHaltedGaugesLength() view returns (uint256)",
+  "function getGaugeAt(uint256 index_) view returns (address)",
+  "function getHaltedGaugeAt(uint256 index_) view returns (address)",
+  "function gaugeToBuilder(address gauge) view returns (address builder)",
+  "function backerRewardPercentage(address builder) view returns (uint64 previous, uint64 next, uint128 cooldownEndTime)",
+];
+
+export const ROOTSTOCK_GAUGE_ABI = [
+  "function rewardShares() view returns (uint256)",
+  "function earned(address rewardToken_, address backer_) external view returns (uint256)",
+  "function allocationOf(address backer) external view returns (uint256 allocation)",
+];
+
+export const ROOTSTOCK_REWARD_DISTRIBUTOR_ABI = [
+  "function defaultRifAmount() view returns (uint256)",
+  "function defaultNativeAmount() view returns (uint256)",
+];
+
+export const ROOTSTOCK_BACKER_MANAGER_ABI = [
+  "function totalPotentialReward() view returns (uint256)",
+  "function backerTotalAllocation(address backer) view returns (uint256 allocation)",
+  "function allocateBatch(address[] gauges_, uint256[] allocations_) external",
+  "function claimBackerRewards(address[] gauges_) external",
+];
diff --git a/src/core/interfaces/app.ts b/src/core/interfaces/app.ts
index 840a4cf..c16db6d 100644
--- a/src/core/interfaces/app.ts
+++ b/src/core/interfaces/app.ts
@@ -7,6 +7,7 @@ export enum Providers {
 export enum Chains {
   ETHEREUM = "ethereum",
   SOLANA = "solana",
+  ROOTSTOCK = "rootstock",
 };
 
 export enum Networks {
diff --git a/src/core/interfaces/portfolio.ts b/src/core/interfaces/portfolio.ts
index 6c5c298..bef5e43 100644
--- a/src/core/interfaces/portfolio.ts
+++ b/src/core/interfaces/portfolio.ts
@@ -4,6 +4,7 @@ export interface Token {
   image: string;
   symbol: string;
   price?: number;
+  coinGeckoId?: string;
 }
 
 export interface BaseTokens {
diff --git a/src/core/interfaces/price.ts b/src/core/interfaces/price.ts
index aa76c2d..b92ae7e 100644
--- a/src/core/interfaces/price.ts
+++ b/src/core/interfaces/price.ts
@@ -1,4 +1,4 @@
-export interface SolanaPriceResponse {
+export interface TokenMarketDataResponse {
   data: {
     getCoinGeckoTokenMarketDataByIds: CoinGeckoToken[],
   }
@@ -22,7 +22,7 @@ export interface CoinGeckoToken {
   current_price: number,
 };
 
-export interface SolanaPriceRequest {
+export interface TokenMarketDataRequest {
   operationName: string | null,
   variables: any,
   query: string,
diff --git a/src/core/interfaces/staking.ts b/src/core/interfaces/staking.ts
index de3fd5c..1132dae 100644
--- a/src/core/interfaces/staking.ts
+++ b/src/core/interfaces/staking.ts
@@ -218,3 +218,10 @@ export interface DelegatorApy {
   grossApy: number,
   netApy: number,
 }
+
+export interface RootstockAbiResponse {
+  data: {
+    network: string,
+    abi: string,
+  }
+}
diff --git a/src/core/services/evmWalletService.ts b/src/core/services/evmWalletService.ts
new file mode 100644
index 0000000..5326cf1
--- /dev/null
+++ b/src/core/services/evmWalletService.ts
@@ -0,0 +1,113 @@
+import { ethers } from "ethers";
+
+import { MIN_BALANCE_EVM } from "../constants";
+
+declare global {
+  interface Window {
+    ethereum?: any;
+  }
+}
+
+export default class EvmWalletService {
+  private static instance: EvmWalletService;
+
+  private provider: ethers.providers.Web3Provider | undefined;
+
+  private readonly rpcProvider: ethers.providers.JsonRpcProvider;
+
+  private readonly rootstockRpc = import.meta.env.VITE_ROOTSTOCK_RPC as string;
+
+  private constructor() {
+    this.rpcProvider = new ethers.providers.JsonRpcProvider(this.rootstockRpc);
+  }
+
+  static getInstance() {
+    if (this.instance != null) {
+      return this.instance;
+    }
+    this.instance = new EvmWalletService();
+    return this.instance;
+  }
+
+  getWeb3Provider() {
+    return this.provider;
+  }
+
+  getRpcProvider() {
+    return this.provider ?? this.rpcProvider;
+  }
+
+  async connectWallet(): Promise<string> {
+    if (!window.ethereum) {
+      throw new Error("EVM wallet provider not detected");
+    }
+
+    this.provider = new ethers.providers.Web3Provider(window.ethereum, "any");
+    await this.ensureRootstockNetwork();
+
+    const accounts: string[] = await this.provider.send("eth_requestAccounts", []);
+    if (!accounts.length) {
+      throw new Error("No accounts found");
+    }
+
+    return ethers.utils.getAddress(accounts[0]);
+  }
+
+  async ensureRootstockNetwork() {
+    if (!this.provider) {
+      return;
+    }
+
+    const targetChainId = Number(import.meta.env.VITE_ROOTSTOCK_CHAIN_ID ?? 30);
+    const hexChainId = `0x${targetChainId.toString(16)}`;
+
+    try {
+      await this.provider.send("wallet_switchEthereumChain", [{ chainId: hexChainId }]);
+    } catch (switchError: any) {
+      if (switchError?.code === 4902) {
+        await this.provider.send("wallet_addEthereumChain", [{
+          chainId: hexChainId,
+          chainName: "Rootstock Mainnet",
+          rpcUrls: [this.rootstockRpc],
+          nativeCurrency: {
+            name: "Rootstock Bitcoin",
+            symbol: "RBTC",
+            decimals: 18,
+          },
+          blockExplorerUrls: ["https://explorer.rootstock.io/"],
+        }]);
+      } else {
+        throw switchError;
+      }
+    }
+  }
+
+  async loadBalance(address: string) {
+    const provider = this.getRpcProvider();
+    const balance = await provider.getBalance(address);
+    const formattedBalance = Number(ethers.utils.formatEther(balance));
+
+    return formattedBalance;
+  }
+
+  async loadTokenBalance(address: string, tokenAddress: string, decimals = 18) {
+    const provider = this.getRpcProvider();
+    const abi = ["function balanceOf(address owner) view returns (uint256)"];
+    const contract = new ethers.Contract(tokenAddress, abi, provider);
+    const balance = await contract.balanceOf(address);
+
+    return Number(ethers.utils.formatUnits(balance, decimals));
+  }
+
+  listenForAccountChanges(handler: (accounts: string[]) => void) {
+    window.ethereum?.on?.("accountsChanged", handler);
+  }
+
+  removeAccountChangeListener(handler: (accounts: string[]) => void) {
+    window.ethereum?.removeListener?.("accountsChanged", handler);
+  }
+
+  async disconnect() {
+    this.provider = undefined;
+  }
+}
diff --git a/src/store/modules/staking/actions.ts b/src/store/modules/staking/actions.ts
index 223a6c7..929d2fe 100644
--- a/src/store/modules/staking/actions.ts
+++ b/src/store/modules/staking/actions.ts
@@ -1,5 +1,5 @@
 import { Buffer } from "buffer";
-import { utils } from "ethers";
+import { ethers, utils } from "ethers";
 import { Commit, Dispatch } from "vuex";
 import {
   createStake,
@@ -10,6 +10,7 @@ import {
   getDelegatorRewards,
 } from "@/core/api";
 import { 
+  Chains,
   CreateStakeRequest,
   GetStakingAccountRequest,
   SendTransactionRequest,
@@ -18,18 +19,380 @@ import {
   PortfolioByChain,
   StakeDeactivateRequest,
   StakeWithdrawRequest,
+  Statuses,
 } from "@/core/interfaces";
 import { Transaction } from "@solana/web3.js";
 import WalletService from "@/core/services/walletService";
+import EvmWalletService from "@/core/services/evmWalletService";
 import { SharedTypes } from "@/store/shared/consts";
-import { BASE_TOKENS } from "@/core/constants";
-import { LAMPORTS_IN_SOL, SOL_FEE } from "@/core/constants";
+import { BASE_TOKENS, LAMPORTS_IN_SOL, ROOTSTOCK_BACKER_MANAGER_ABI, ROOTSTOCK_BACKER_MANAGER_ADDRESS, ROOTSTOCK_BUILDER_REGISTRY_ABI, ROOTSTOCK_BUILDER_REGISTRY_ADDRESS, ROOTSTOCK_GAUGE_ABI, ROOTSTOCK_RBTC_TOKEN_ADDRESS, ROOTSTOCK_REWARD_DISTRIBUTOR_ABI, ROOTSTOCK_REWARD_DISTRIBUTOR_ADDRESS, ROOTSTOCK_RIF_TOKEN_ADDRESS, ROOTSTOCK_STRIF_TOKEN_ADDRESS, RIF_TOKEN_ABI, SOL_FEE, STRIF_TOKEN_ABI } from "@/core/constants";
 import { deleteStorageStakingData, getStorageStakingData, saveStorageStakingAccounts } from "@/utils/storage";
 
 import { StakingState } from "./mutations";
 
 const walletService = WalletService.getInstance();
+const evmWalletService = EvmWalletService.getInstance();
 let portfolioUpdateTimeout: ReturnType<typeof setTimeout> | undefined;
+const ROOTSTOCK_REWARD_DECIMALS = 18;
+const ROOTSTOCK_ALLOCATION_DECIMALS = 18;
+
+const ROOTSTOCK_REWARD_ASSETS = [
+  { symbol: "rbtc", address: ROOTSTOCK_RBTC_TOKEN_ADDRESS },
+  { symbol: "rif", address: ROOTSTOCK_RIF_TOKEN_ADDRESS },
+];
+
+function getBackerRewardPercentage(
+  previous: ethers.BigNumber,
+  next: ethers.BigNumber,
+  cooldownEndTime: ethers.BigNumber,
+  timestampInSeconds?: number
+) {
+  const currentTimestamp = timestampInSeconds ?? Math.floor(Date.now() / 1000);
+  const cooldownTimestamp = cooldownEndTime.toNumber();
+  const current = currentTimestamp < cooldownTimestamp ? previous : next;
+
+  return {
+    current,
+    next,
+    cooldownEndTime,
+  };
+}
+
+async function allocateRootstockBuilders(
+  signer: ethers.Signer,
+  accountAddress: string
+): Promise<string | null> {
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error("EVM provider not found");
+  }
+
+  const registryContract = new ethers.Contract(
+    ROOTSTOCK_BUILDER_REGISTRY_ADDRESS,
+    ROOTSTOCK_BUILDER_REGISTRY_ABI,
+    provider
+  );
+  const rewardDistributorContract = new ethers.Contract(
+    ROOTSTOCK_REWARD_DISTRIBUTOR_ADDRESS,
+    ROOTSTOCK_REWARD_DISTRIBUTOR_ABI,
+    provider
+  );
+  const backerManagerContract = new ethers.Contract(
+    ROOTSTOCK_BACKER_MANAGER_ADDRESS,
+    ROOTSTOCK_BACKER_MANAGER_ABI,
+    signer
+  );
+  const stRifContract = new ethers.Contract(
+    ROOTSTOCK_STRIF_TOKEN_ADDRESS,
+    STRIF_TOKEN_ABI,
+    provider
+  );
+
+  await Promise.all([
+    rewardDistributorContract.defaultRifAmount(),
+    rewardDistributorContract.defaultNativeAmount(),
+    backerManagerContract.totalPotentialReward(),
+    backerManagerContract.backerTotalAllocation(accountAddress),
+  ]);
+
+  const [activeLength, haltedLength] = await Promise.all([
+    registryContract.getGaugesLength(),
+    registryContract.getHaltedGaugesLength(),
+  ]);
+
+  const activeLen = Number(activeLength.toString()) ?? 0;
+  const haltedLen = Number(haltedLength.toString()) ?? 0;
+
+  const activeGauges = await Promise.all(
+    Array.from({ length: activeLen }, (_, index) => registryContract.getGaugeAt(index))
+  );
+  const haltedGauges = await Promise.all(
+    Array.from({ length: haltedLen }, (_, index) => registryContract.getHaltedGaugeAt(index))
+  );
+  const gauges = [...activeGauges, ...haltedGauges];
+  if (!gauges.length) {
+    return null;
+  }
+
+  const builders = await Promise.all(
+    gauges.map((gauge: string) => registryContract.gaugeToBuilder(gauge))
+  );
+
+  const backerRewardPercentageRaw = await Promise.all(
+    builders.map((builder: string) => registryContract.backerRewardPercentage(builder))
+  );
+
+  const myCurrentAllocation = await Promise.all(
+    gauges.map((gauge: string) => {
+      const contract = new ethers.Contract(gauge, ROOTSTOCK_GAUGE_ABI, provider);
+      return contract.allocationOf(accountAddress);
+    })
+  );
+
+
+  const buildersList = builders.map((builder: string, index: number) => {
+    const backerRewardPercentage = getBackerRewardPercentage(
+      backerRewardPercentageRaw[index].previous,
+      backerRewardPercentageRaw[index].next,
+      backerRewardPercentageRaw[index].cooldownEndTime
+    );
+    const backerRewardShare = 100 * Number(
+      ethers.utils.formatUnits(
+        (backerRewardPercentage?.current ?? 0).toString(),
+        ROOTSTOCK_REWARD_DECIMALS
+      )
+    );
+
+    return {
+      builderAddress: builder,
+      backerRewardShare,
+      myAllocation: myCurrentAllocation[index] as ethers.BigNumber,
+      gauge: gauges[index],
+    };
+  });
+
+  let topBuilders = buildersList
+    .slice()
+    .sort((a, b) => b.backerRewardShare - a.backerRewardShare)
+    .slice(0, 5);
+
+  const myStRifBalance = await stRifContract.balanceOf(accountAddress);
+  const totalAllocated = myCurrentAllocation.reduce(
+    (acc: ethers.BigNumber, allocation: ethers.BigNumber) => acc.add(allocation),
+    ethers.constants.Zero
+  );
+  const availableAllocation = myStRifBalance.gt(totalAllocated)
+    ? myStRifBalance.sub(totalAllocated)
+    : ethers.constants.Zero;
+  const minAllocation = ethers.utils.parseUnits("1", ROOTSTOCK_ALLOCATION_DECIMALS);
+
+  if (availableAllocation.gt(0) && topBuilders.length) {
+    const newAlloc = availableAllocation.div(topBuilders.length);
+
+    if (newAlloc.gte(minAllocation)) {
+      topBuilders = topBuilders.map((builder) => ({
+        ...builder,
+        myAllocation: builder.myAllocation.add(newAlloc),
+      }));
+    } else {
+      topBuilders[0] = {
+        ...topBuilders[0],
+        myAllocation: topBuilders[0].myAllocation.add(newAlloc),
+      };
+    }
+  }
+
+  const buildersWithAllocs = topBuilders.filter((builder) => builder.myAllocation.gt(0));
+  if (!buildersWithAllocs.length) {
+    return null;
+  }
+
+  const tx = await backerManagerContract.allocateBatch(
+    buildersWithAllocs.map((builder) => builder.gauge),
+    buildersWithAllocs.map((builder) => builder.myAllocation)
+  );
+
+  const receipt = await tx.wait();
+  return receipt?.transactionHash ?? tx.hash ?? null;
+}
+
+async function deAllocateRootstockBuilders(
+  signer: ethers.Signer,
+  accountAddress: string
+): Promise<string | null> {
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error("EVM provider not found");
+  }
+
+  const registryContract = new ethers.Contract(
+    ROOTSTOCK_BUILDER_REGISTRY_ADDRESS,
+    ROOTSTOCK_BUILDER_REGISTRY_ABI,
+    provider
+  );
+  const rewardDistributorContract = new ethers.Contract(
+    ROOTSTOCK_REWARD_DISTRIBUTOR_ADDRESS,
+    ROOTSTOCK_REWARD_DISTRIBUTOR_ABI,
+    provider
+  );
+  const backerManagerContract = new ethers.Contract(
+    ROOTSTOCK_BACKER_MANAGER_ADDRESS,
+    ROOTSTOCK_BACKER_MANAGER_ABI,
+    signer
+  );
+
+  await Promise.all([
+    rewardDistributorContract.defaultRifAmount(),
+    rewardDistributorContract.defaultNativeAmount(),
+    backerManagerContract.totalPotentialReward(),
+    backerManagerContract.backerTotalAllocation(accountAddress),
+  ]);
+
+  const [activeLength, haltedLength] = await Promise.all([
+    registryContract.getGaugesLength(),
+    registryContract.getHaltedGaugesLength(),
+  ]);
+
+  const activeLen = Number(activeLength.toString()) ?? 0;
+  const haltedLen = Number(haltedLength.toString()) ?? 0;
+
+  const activeGauges = await Promise.all(
+    Array.from({ length: activeLen }, (_, index) => registryContract.getGaugeAt(index))
+  );
+  const haltedGauges = await Promise.all(
+    Array.from({ length: haltedLen }, (_, index) => registryContract.getHaltedGaugeAt(index))
+  );
+  const gauges = [...activeGauges, ...haltedGauges];
+  if (!gauges.length) {
+    return null;
+  }
+
+  const builders = await Promise.all(
+    gauges.map((gauge: string) => registryContract.gaugeToBuilder(gauge))
+  );
+
+  const myCurrentAllocation = await Promise.all(
+    gauges.map((gauge: string) => {
+      const contract = new ethers.Contract(gauge, ROOTSTOCK_GAUGE_ABI, provider);
+      return contract.allocationOf(accountAddress);
+    })
+  );
+
+
+  const buildersList = builders.map((builder: string, index: number) => {
+
+    return {
+      builderAddress: builder,
+      myAllocation: myCurrentAllocation[index] as ethers.BigNumber,
+      gauge: gauges[index],
+    };
+  });
+
+  const buildersWithAllocs = buildersList.filter((builder) => builder.myAllocation.gt(0));
+  if (!buildersWithAllocs.length) {
+    return null;
+  }
+
+  const tx = await backerManagerContract.allocateBatch(
+    buildersWithAllocs.map((builder) => builder.gauge),
+    buildersWithAllocs.map((builder) => builder.myAllocation)
+  );
+
+  const receipt = await tx.wait();
+  return receipt?.transactionHash ?? tx.hash ?? null;
+}
+
+async function claimRootstockRewards(
+  signer: ethers.Signer,
+  accountAddress: string
+): Promise<string | null> {
+  const provider = signer.provider;
+  if (!provider) {
+    throw new Error("EVM provider not found");
+  }
+
+  const registryContract = new ethers.Contract(
+    ROOTSTOCK_BUILDER_REGISTRY_ADDRESS,
+    ROOTSTOCK_BUILDER_REGISTRY_ABI,
+    provider
+  );
+  const backerManagerContract = new ethers.Contract(
+    ROOTSTOCK_BACKER_MANAGER_ADDRESS,
+    ROOTSTOCK_BACKER_MANAGER_ABI,
+    signer
+  );
+
+  const [activeLength, haltedLength] = await Promise.all([
+    registryContract.getGaugesLength(),
+    registryContract.getHaltedGaugesLength(),
+  ]);
+
+  const activeLen = Number(activeLength.toString()) ?? 0;
+  const haltedLen = Number(haltedLength.toString()) ?? 0;
+
+  const activeGauges = await Promise.all(
+    Array.from({ length: activeLen }, (_, index) => registryContract.getGaugeAt(index))
+  );
+  const haltedGauges = await Promise.all(
+    Array.from({ length: haltedLen }, (_, index) => registryContract.getHaltedGaugeAt(index))
+  );
+  const gauges = [...activeGauges, ...haltedGauges];
+  if (!gauges.length) {
+    return null;
+  }
+
+  const myCurrentAllocation = await Promise.all(
+    gauges.map((gauge: string) => {
+      const contract = new ethers.Contract(gauge, ROOTSTOCK_GAUGE_ABI, provider);
+      return contract.allocationOf(accountAddress);
+    })
+  );
+
+  const gaugesWithAllocs = gauges.filter((_, index) => myCurrentAllocation[index].gt(0));
+  if (!gaugesWithAllocs.length) {
+    return null;
+  }
+
+  const tx = await backerManagerContract.claimBackerRewards(gaugesWithAllocs);
+  const receipt = await tx.wait();
+  return receipt?.transactionHash ?? tx.hash ?? null;
+}
+
+async function loadRootstockTotalRewards(provider: ethers.providers.Provider, accountAddress: string, prices: Record<string, number>) {
+  const registryContract = new ethers.Contract(
+    ROOTSTOCK_BUILDER_REGISTRY_ADDRESS,
+    ROOTSTOCK_BUILDER_REGISTRY_ABI,
+    provider,
+  );
+
+  const [activeLength, haltedLength] = await Promise.all([
+    registryContract.getGaugesLength(),
+    registryContract.getHaltedGaugesLength(),
+  ]);
+
+  const activeLen = Number(activeLength.toString()) ?? 0;
+  const haltedLen = Number(haltedLength.toString()) ?? 0;
+
+  const activeGauges = await Promise.all(
+    Array.from({ length: activeLen }, (_, index) => registryContract.getGaugeAt(index))
+  );
+  const haltedGauges = await Promise.all(
+    Array.from({ length: haltedLen }, (_, index) => registryContract.getHaltedGaugeAt(index))
+  );
+
+  const gauges = [...activeGauges, ...haltedGauges];
+  if (!gauges.length) {
+    return 0;
+  }
+
+  let totalEarnedUsd = 0;
+  for (const asset of ROOTSTOCK_REWARD_ASSETS) {
+    const price = prices?.[asset.symbol] ?? 0;
+    if (!price) {
+      continue;
+    }
+
+    const earnedValues = await Promise.all(
+      gauges.map((gauge: string) => {
+        const contract = new ethers.Contract(gauge, ROOTSTOCK_GAUGE_ABI, provider);
+        return contract.earned(asset.address, accountAddress);
+      })
+    );
+
+    const earnedAmount = earnedValues
+      .map((value: ethers.BigNumber) => ethers.utils.formatUnits(value, ROOTSTOCK_REWARD_DECIMALS))
+      .reduce((acc: number, earned: string) => acc + Number(earned), 0);
+
+    totalEarnedUsd += earnedAmount * price;
+  }
+
+  const rifPrice = prices?.rif ?? 0;
+  if (!rifPrice) {
+    return 0;
+  }
+
+  return totalEarnedUsd / rifPrice;
+}
 
 export const actions = {
   async createStakeAction ({ state, commit, rootGetters }: { 
@@ -42,6 +405,12 @@ export const actions = {
       const chain = rootGetters[SharedTypes.CHAIN_GETTER];
       const network = rootGetters[SharedTypes.NETWORK_GETTER];
 
+      if (chain === Chains.ROOTSTOCK) {
+        commit("setStakingData", [null, 0]);
+        commit("updateStakingLoadingState", false);
+        return;
+      }
+
       const amount = parseFloat(utils.parseUnits(state.stakingAmount as string, 9).toString());
       const balance = parseFloat(utils.parseUnits(`${walletBalance}`, 9).toString());
       
@@ -72,13 +441,66 @@ export const actions = {
     state: StakingState,
     commit: Commit,
     rootGetters: any,
-  }, signedTransaction: string) {
+  }, signedTransaction: string | null) {
     commit("updateLoadingState", true);
     const chain = rootGetters[SharedTypes.CHAIN_GETTER];
     const network = rootGetters[SharedTypes.NETWORK_GETTER];
+    const walletAccount = rootGetters[SharedTypes.WALLET_ACCOUNT_GETTER];
 
     try {
+      if (chain === Chains.ROOTSTOCK) {
+        commit("resetRootstockStakeFlowSteps");
+
+        if (!walletAccount?.address) {
+          throw new Error("Wallet account not found");
+        }
+
+        if (!state.stakingAmount) {
+          throw new Error("Staking amount is not defined");
+        }
+
+        const provider = evmWalletService.getWeb3Provider();
+        if (!provider) {
+          throw new Error("EVM wallet is not connected");
+        }
+
+        const signer = provider.getSigner();
+        const parsedAmount = ethers.utils.parseEther(state.stakingAmount);
+
+        if (parsedAmount.lte(0)) {
+          throw new Error("Staking amount should be greater than zero");
+        }
+
+        const rifContract = new ethers.Contract(ROOTSTOCK_RIF_TOKEN_ADDRESS, RIF_TOKEN_ABI, signer);
+        const stRifContract = new ethers.Contract(ROOTSTOCK_STRIF_TOKEN_ADDRESS, STRIF_TOKEN_ABI, signer);
+        const rifBalance = await rifContract.balanceOf(walletAccount.address);
+
+        if (rifBalance.lt(parsedAmount)) {
+          throw new Error("You don't have enough RIF for staking");
+        }
+
+        commit("setRootstockStakeFlowStep", ["approve", "in_progress"]);
+        const approveTx = await rifContract.approve(ROOTSTOCK_STRIF_TOKEN_ADDRESS, parsedAmount);
+        await approveTx.wait();
+        commit("setRootstockStakeFlowStep", ["approve", "done"]);
+
+        commit("setRootstockStakeFlowStep", ["stake", "in_progress"]);
+        const stakeTx = await stRifContract.depositAndDelegate(walletAccount.address, parsedAmount);
+        const receipt = await stakeTx.wait();
+        commit("setRootstockStakeFlowStep", ["stake", "done"]);
+
+        commit("setRootstockStakeFlowStep", ["backBuilders", "in_progress"]);
+        const allocationTxId = await allocateRootstockBuilders(signer, walletAccount.address);
+        commit("setRootstockStakeFlowStep", ["backBuilders", "done"]);
+        commit("setTxId", allocationTxId ?? receipt?.transactionHash ?? stakeTx.hash);
+        commit("updateLoadingState", false);
+        return receipt;
+      }
+
       if (state.stakingData) {
+        if (!signedTransaction) {
+          throw new Error("Signed transaction is required");
+        }
         const txPayload: SendTransactionRequest = {
           signedTransaction,
         }
@@ -102,6 +524,42 @@ export const actions = {
     }
   },
 
+  async claimRootstockRewardsAction ({ commit, rootGetters, dispatch }: { 
+    commit: Commit,
+    rootGetters: any,
+    dispatch: Dispatch,
+  }) {
+    commit("updateLoadingState", true);
+    const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+    const walletAccount = rootGetters[SharedTypes.WALLET_ACCOUNT_GETTER];
+
+    try {
+      if (chain !== Chains.ROOTSTOCK) {
+        throw new Error("Rootstock rewards are not available on this network");
+      }
+
+      if (!walletAccount?.address) {
+        throw new Error("Wallet account not found");
+      }
+
+      const provider = evmWalletService.getWeb3Provider();
+      if (!provider) {
+        throw new Error("EVM wallet is not connected");
+      }
+
+      const signer = provider.getSigner();
+      const txId = await claimRootstockRewards(signer, walletAccount.address);
+      if (txId) {
+        commit("setTxId", txId);
+      }
+      await dispatch("loadStakingAccounts", walletAccount.address);
+    } catch (e: any) {
+      commit("setError", e?.message);
+    } finally {
+      commit("updateLoadingState", false);
+    }
+  },
+
   async setDeactivatingStakeAction ({ state, commit, rootGetters }: { 
     state: StakingState,
     commit: Commit,
@@ -257,6 +715,53 @@ export const actions = {
     }
   },
 
+  async rootstockUnstakeAction ({ commit, rootGetters, dispatch }: {
+    commit: Commit,
+    rootGetters: any,
+    dispatch: Dispatch,
+  }, amount: number) {
+    try {
+      commit("updateLoadingState", true);
+      const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+      const walletAccount = rootGetters[SharedTypes.WALLET_ACCOUNT_GETTER];
+
+      if (chain !== Chains.ROOTSTOCK) {
+        throw new Error("Rootstock unstake action is not available on this network");
+      }
+
+      if (!walletAccount?.address) {
+        throw new Error("Wallet account not found");
+      }
+
+      if (!amount || amount <= 0) {
+        throw new Error("Nothing to unstake");
+      }
+
+      const provider = evmWalletService.getWeb3Provider();
+      if (!provider) {
+        throw new Error("EVM wallet is not connected");
+      }
+
+      const signer = provider.getSigner();
+      const stRifContract = new ethers.Contract(ROOTSTOCK_STRIF_TOKEN_ADDRESS, STRIF_TOKEN_ABI, signer);
+      const parsedAmount = ethers.utils.parseEther(amount.toString());
+
+      await deAllocateRootstockBuilders(signer, walletAccount.address);
+      
+      const withdrawTx = await stRifContract.withdrawTo(walletAccount.address, parsedAmount);
+      const receipt = await withdrawTx.wait();
+
+      commit("setTxId", receipt?.transactionHash ?? withdrawTx.hash);
+      commit("updateLoadingState", false);
+      await dispatch("loadStakingAccounts", walletAccount.address);
+
+      return receipt;
+    } catch (e: any) {
+      commit("updateLoadingState", false);
+      commit("setError", e?.message);
+    }
+  },
+
   async loadStakingAccounts ({ state, commit, rootGetters, dispatch }: {
     state: StakingState,
     commit: Commit,
@@ -268,6 +773,64 @@ export const actions = {
     const account = rootGetters[SharedTypes.WALLET_ACCOUNT_GETTER];
 
     try {
+      if (chain === Chains.ROOTSTOCK) {
+        try {
+          if (account) {
+            commit("updateLoadingState", true);
+            const provider = evmWalletService.getRpcProvider();
+            const stRifContract = new ethers.Contract(ROOTSTOCK_STRIF_TOKEN_ADDRESS, STRIF_TOKEN_ABI, provider);
+            const stakedBalance = await stRifContract.balanceOf(accountAddress);
+            const formattedBalance = Number(ethers.utils.formatEther(stakedBalance));
+            const prices = rootGetters[SharedTypes.PRICE_GETTER] ?? {};
+            let totalRewards = 0;
+            try {
+              totalRewards = await loadRootstockTotalRewards(provider, accountAddress, prices);
+            } catch (error) {
+              console.error(`Failed to load Rootstock rewards: ${error}`);
+            }
+
+            if (formattedBalance > 0) {
+              const rootstockItem: PortfolioItem = {
+                balance: formattedBalance,
+                reward: totalRewards,
+                status: Statuses.ACTIVE,
+                stakeAccount: accountAddress,
+                stakeAuthority: accountAddress,
+                voteAccount: "",
+                withdrawAuthority: accountAddress,
+                provider: Providers.p2p,
+                chain,
+                isEnabled: true,
+              };
+
+              const portfolioByChain: PortfolioByChain = {
+                items: [rootstockItem],
+                totalStaked: formattedBalance,
+                totalRewards,
+                avgRewards: 0,
+                baseToken: BASE_TOKENS[chain],
+              };
+
+              commit("setStakingAccounts", [portfolioByChain, chain]);
+            } else {
+              deleteStorageStakingData();
+              commit("emptyPortfolio");
+            }
+          } else {
+            deleteStorageStakingData();
+            commit("emptyPortfolio");
+          }
+        } catch (error) {
+          console.error(`Failed to load Rootstock staking data: ${error}`);
+        }
+
+        portfolioUpdateTimeout = setTimeout(async () => {
+          await dispatch("loadStakingAccounts", accountAddress);
+        }, 15000);
+        commit("updateLoadingState", false);
+        return;
+      }
+
       if (account) {
         const payload: GetStakingAccountRequest = {
           stakeAuthorities: [accountAddress],
diff --git a/src/store/modules/staking/consts.ts b/src/store/modules/staking/consts.ts
index 9ad1d2c..6822abb 100644
--- a/src/store/modules/staking/consts.ts
+++ b/src/store/modules/staking/consts.ts
@@ -6,6 +6,8 @@ export enum StakingTypes {
   UPDATE_VALIDATOR_DATA = "stakingStore/updateValidatorData",
   UPDATE_STAKING_DATA = "stakingStore/updateStakingData",
   UPDATE_LOADING_STATE = "stakingStore/updateLoadingState",
+  SET_ROOTSTOCK_STAKE_FLOW_STEP = "stakingStore/setRootstockStakeFlowStep",
+  RESET_ROOTSTOCK_STAKE_FLOW_STEPS = "stakingStore/resetRootstockStakeFlowSteps",
   EMPTY_PORTFOLIO_STATE = "stakingStore/emptyPortfolio",
   SET_ERROR_STATE = "stakingStore/setErrorState",
   
@@ -18,6 +20,8 @@ export enum StakingTypes {
   LOAD_STAKING_ACCOUNTS_ACTION = "stakingStore/loadStakingAccounts",
   WITHDRAW_STAKE_ACTION = "stakingStore/withdrawStakeAction",
   START_WITHDRAW_ACTION = "stakingStore/startWithdrawStakeAction",
+  ROOTSTOCK_UNSTAKE_ACTION = "stakingStore/rootstockUnstakeAction",
+  CLAIM_ROOTSTOCK_REWARDS_ACTION = "stakingStore/claimRootstockRewardsAction",
   UPDATE_VALIDATOR_ACTION = "stakingStore/updateValidatorAction",
   UPDATE_STAKING_ACTION = "stakingStore/updateStakingAction",
   EMPTY_STAKING_ACCOUNTS_ACTION = "stakingStore/emptyStakingAccountsAction",
@@ -36,6 +40,7 @@ export enum StakingTypes {
   IS_STAKING_LOADING_GETTER = "stakingStore/getIsStakingLoading",
   STAKING_DATA_GETTER = "stakingStore/getStakingData",
   STAKING_FEE_GETTER = "stakingStore/getStakingFee",
+  ROOTSTOCK_STAKE_FLOW_STEPS_GETTER = "stakingStore/getRootstockStakeFlowSteps",
   DEACTIVATING_FEE_GETTER = "stakingStore/getDeactivatingFee",
   WITHDRAW_FEE_GETTER = "stakingStore/getWithdrawFee",
   ERROR_GETTER = "stakingStore/getError",
diff --git a/src/store/modules/staking/getters.ts b/src/store/modules/staking/getters.ts
index 25b4e77..f116c8a 100644
--- a/src/store/modules/staking/getters.ts
+++ b/src/store/modules/staking/getters.ts
@@ -17,7 +17,8 @@ export const getters = {
   getIsStakingLoading: (state: StakingState) => state.isStakingLoading,
   getStakingData: (state: StakingState) => state.stakingData,
   getStakingFee: (state: StakingState) => state.stakingFee,
+  getRootstockStakeFlowSteps: (state: StakingState) => state.rootstockStakeFlowSteps,
   getDeactivatingFee: (state: StakingState) => state.deactivatingFee,
   getWithdrawFee: (state: StakingState) => state.withdrawFee,
   getError: (state: StakingState) => state.error,
-};
\ No newline at end of file
+};
diff --git a/src/store/modules/staking/mutations.ts b/src/store/modules/staking/mutations.ts
index b49d1b6..25132c3 100644
--- a/src/store/modules/staking/mutations.ts
+++ b/src/store/modules/staking/mutations.ts
@@ -24,6 +24,11 @@ export interface StakingState {
   validators: ValidatorsType,
   stakingData: CreateStakeResponseResult | null,
   stakingFee: number,
+  rootstockStakeFlowSteps: {
+    approve: "pending" | "in_progress" | "done",
+    stake: "pending" | "in_progress" | "done",
+    backBuilders: "pending" | "in_progress" | "done",
+  },
   deactivatingData: StakeDeactivateResponseResult | null,
   deactivatingFee: number,
   withdrawData: StakeWithdrawResponseData | null,
@@ -46,6 +51,12 @@ export const initialState: StakingState = {
       chainData: chainsData[Chains.SOLANA],
       apr: "",
       token: BASE_TOKENS[Chains.SOLANA],
+    },
+    [Chains.ROOTSTOCK]: {
+      name: "Rootstock staking",
+      chainData: chainsData[Chains.ROOTSTOCK],
+      apr: "",
+      token: BASE_TOKENS[Chains.ROOTSTOCK],
     }
   },
   validators: {
@@ -54,11 +65,21 @@ export const initialState: StakingState = {
         validatorData: validators[Providers.p2p][Chains.SOLANA].validatorData,
         apy: "",
         fee: "",
+      },
+      [Chains.ROOTSTOCK]: {
+        validatorData: validators[Providers.p2p][Chains.ROOTSTOCK].validatorData,
+        apy: "",
+        fee: "",
       }
     }
   },
   stakingData: null,
   stakingFee: 0,
+  rootstockStakeFlowSteps: {
+    approve: "pending",
+    stake: "pending",
+    backBuilders: "pending",
+  },
   deactivatingData: null,
   deactivatingFee: 0,
   withdrawData: null,
@@ -113,10 +134,23 @@ export const mutations = {
   updateStakingLoadingState(state: StakingState, isLoading: boolean) {
     state.isStakingLoading = isLoading;
   },
-  setStakingData(state: StakingState, [stakngData, fee]: [CreateStakeResponseResult, number]) {
+  setStakingData(state: StakingState, [stakngData, fee]: [CreateStakeResponseResult | null, number]) {
     state.stakingData = stakngData;
     state.stakingFee = fee;
   },
+  resetRootstockStakeFlowSteps(state: StakingState) {
+    state.rootstockStakeFlowSteps = {
+      approve: "pending",
+      stake: "pending",
+      backBuilders: "pending",
+    };
+  },
+  setRootstockStakeFlowStep(
+    state: StakingState,
+    [step, status]: ["approve" | "stake" | "backBuilders", "pending" | "in_progress" | "done"]
+  ) {
+    state.rootstockStakeFlowSteps[step] = status;
+  },
   setDeactivatingData(state: StakingState, [deactivatingData, fee]: [StakeDeactivateResponseResult, number]) {
     state.deactivatingData = deactivatingData;
     state.deactivatingFee = fee;
diff --git a/src/store/shared/actions.ts b/src/store/shared/actions.ts
index b12e45e..0e07eb0 100644
--- a/src/store/shared/actions.ts
+++ b/src/store/shared/actions.ts
@@ -1,31 +1,46 @@
 import { Commit, Dispatch } from "vuex";
-import { BASE_TOKENS } from "@/core/constants/index";
+import { ethers } from "ethers";
+import { BASE_TOKENS, ROOTSTOCK_RIF_TOKEN_ADDRESS, WALLET_TYPES } from "@/core/constants/index";
 import WalletService from "@/core/services/walletService";
+import EvmWalletService from "@/core/services/evmWalletService";
 import { StakingTypes } from "../modules/staking/consts";
-import { getNetworkAPR, getSolanaPrice, getValidatorAPY, getValidatorFee } from "@/core/api";
+import { getNetworkAPR, getValidatorAPY, getValidatorFee, getRootstockAbi } from "@/core/api";
+import { getTokenMarketData } from "@/core/api/price";
 import { SharedTypes } from "./consts";
-import { Providers } from "@/core/interfaces";
+import { Chains, Providers } from "@/core/interfaces";
 import { Account } from "@/types/account";
+import { SharedState } from "./mutations";
 
 const walletService = WalletService.getInstance();
+const evmWalletService = EvmWalletService.getInstance();
+let evmAccountChangeHandler: ((accounts: string[]) => void) | null = null;
 
 export const actions = {
   async walletConnectedAction (
-    { commit, dispatch } : 
-    { commit: Commit, dispatch: Dispatch },
+    { commit, dispatch, rootGetters } :
+    { commit: Commit, dispatch: Dispatch, rootGetters: any },
     address: string,
   ) {
     try {
-      await walletService.init();
-      await dispatch("loadWalletBalance", address);
+      const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+      if (chain === Chains.SOLANA) {
+        await walletService.init();
+      }
 
       const accountData: Account = {
-        name: "Wallet",
-        image: require("@/assets/pic/account1.png"),
+        name: chain === Chains.ROOTSTOCK ? "EVM Wallet" : "Wallet",
+        image: chain === Chains.ROOTSTOCK
+          ? require("@/assets/pic/ethereum.network.png")
+          : require("@/assets/pic/account1.png"),
         address: address,
         isLedger: false,
       };
       commit("setAccount", accountData);
+      if (chain === Chains.ROOTSTOCK) {
+        commit("setProvider", evmWalletService.getWeb3Provider());
+        commit("setWalletType", WALLET_TYPES.METAMASK);
+      }
+      await dispatch("loadWalletBalance", address);
       await dispatch(StakingTypes.LOAD_STAKING_ACCOUNTS_ACTION, address, { root: true });
     } catch (error) {
       let message = 'Unknown Error'
@@ -37,12 +52,23 @@ export const actions = {
   },
 
   async loadWalletBalance(
-    { commit, dispatch } :
-    { commit: Commit, dispatch: Dispatch },
+    { commit, dispatch, rootGetters } :
+    { commit: Commit, dispatch: Dispatch, rootGetters: any },
     address: string
   ) {
-    const solBalance = await walletService.loadBalance(address) as number;
-    commit("setBalance", solBalance);
+    const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+    const connectedAccount = rootGetters[SharedTypes.WALLET_ACCOUNT_GETTER];
+    if (!connectedAccount || connectedAccount.address !== address) {
+      return;
+    }
+
+    let balance = 0;
+    if (chain === Chains.SOLANA) {
+      balance = await walletService.loadBalance(address) as number ?? 0;
+    } else if (chain === Chains.ROOTSTOCK) {
+      balance = await evmWalletService.loadTokenBalance(address, ROOTSTOCK_RIF_TOKEN_ADDRESS) as number;
+    }
+    commit("setBalance", balance);
 
     setTimeout(async () => {
       await dispatch("loadWalletBalance", address);
@@ -59,30 +85,52 @@ export const actions = {
     rootGetters: any
   }) {
     try {
-      const solPrice = await getSolanaPrice();
-      const solPriceData = solPrice.data.getCoinGeckoTokenMarketDataByIds[0];
-      commit("setPrice", [BASE_TOKENS.solana.symbol, solPriceData.current_price]);
+      const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+      const token = BASE_TOKENS[chain];
+      const tokenId = token?.coinGeckoId ?? "solana";
+      const tokenPriceResponse = await getTokenMarketData(tokenId);
+
+      const tokenPriceData = tokenPriceResponse.data.getCoinGeckoTokenMarketDataByIds[0];
+      commit("setPrice", [token.symbol, tokenPriceData.current_price]);
       commit("setPriceStats", 
         [
-          solPriceData.price_change_percentage_24h,
-          solPriceData.price_change_24h,
-          solPriceData.sparkline_in_24h.price,
-          solPriceData.market_cap,
+          tokenPriceData.price_change_percentage_24h,
+          tokenPriceData.price_change_24h,
+          tokenPriceData.sparkline_in_24h.price,
+          tokenPriceData.market_cap,
         ]
       );
 
-      const chain = rootGetters[SharedTypes.CHAIN_GETTER];
-      const networkAPR = await getNetworkAPR(chain);
-      const validatorAPY = await getValidatorAPY(chain);
-      const validatorFee = await getValidatorFee(chain);
-
-      await dispatch(StakingTypes.UPDATE_STAKING_ACTION, [chain, networkAPR.result.list[0].networkApr], { root: true });
-      await dispatch(StakingTypes.UPDATE_VALIDATOR_ACTION, [
-        Providers.p2p,
-        chain,
-        validatorAPY.result.list[0].apy,
-        validatorFee.result.list[0].fee,
-      ], { root: true });
+      if (chain === Chains.ROOTSTOCK) {
+        const rbtcPriceResponse = await getTokenMarketData("rootstock");
+        const rbtcPriceData = rbtcPriceResponse.data.getCoinGeckoTokenMarketDataByIds[0];
+        commit("setPrice", ["rbtc", rbtcPriceData.current_price]);
+      }
+
+      if (chain === Chains.ROOTSTOCK) {
+        const abiResponse = await getRootstockAbi();
+        const abiValue = abiResponse?.data?.abi ?? "0";
+
+        await dispatch(StakingTypes.UPDATE_STAKING_ACTION, [chain, abiValue], { root: true });
+        await dispatch(StakingTypes.UPDATE_VALIDATOR_ACTION, [
+          Providers.p2p,
+          chain,
+          "0",
+          "0",
+        ], { root: true });
+      } else {
+        const networkAPR = await getNetworkAPR(chain);
+        const validatorAPY = await getValidatorAPY(chain);
+        const validatorFee = await getValidatorFee(chain);
+
+        await dispatch(StakingTypes.UPDATE_STAKING_ACTION, [chain, networkAPR.result.list[0].networkApr], { root: true });
+        await dispatch(StakingTypes.UPDATE_VALIDATOR_ACTION, [
+          Providers.p2p,
+          chain,
+          validatorAPY.result.list[0].apy,
+          validatorFee.result.list[0].fee,
+        ], { root: true });
+      }
     } catch (e: any) {
       console.log(e?.message);
       setTimeout(async () => {
@@ -99,11 +147,86 @@ export const actions = {
 
     commit("setAccount", null);
     commit("setWalletType", null);
+    commit("setProvider", null);
+    commit("setBalance", 0);
+    if (evmAccountChangeHandler) {
+      evmWalletService.removeAccountChangeListener(evmAccountChangeHandler);
+      evmAccountChangeHandler = null;
+    }
+    await evmWalletService.disconnect();
   },
 
   async connectModalAction({ commit }: {
     commit: Commit,
   }, value: boolean ) {
     commit("setIsConnectModalVisible", value);
-  }
+  },
+
+  async connectEvmWalletAction({ dispatch, commit, rootGetters }: {
+    dispatch: Dispatch,
+    commit: Commit,
+    rootGetters: any,
+  }) {
+    try {
+      const chain = rootGetters[SharedTypes.CHAIN_GETTER];
+      if (chain !== Chains.ROOTSTOCK) {
+        throw new Error("EVM wallet connection is only available for Rootstock network");
+      }
+
+      const address = await evmWalletService.connectWallet();
+      commit("setProvider", evmWalletService.getWeb3Provider());
+      commit("setWalletType", WALLET_TYPES.METAMASK);
+      if (evmAccountChangeHandler) {
+        evmWalletService.removeAccountChangeListener(evmAccountChangeHandler);
+      }
+      evmAccountChangeHandler = async (accounts: string[]) => {
+        if (!accounts.length) {
+          await dispatch(SharedTypes.DISCONNECT_WALLET_ACTION, undefined, { root: true });
+        } else {
+          await dispatch(SharedTypes.CONNECTED_WALLET_ACTION, ethers.utils.getAddress(accounts[0]), { root: true });
+        }
+      };
+      evmWalletService.listenForAccountChanges(evmAccountChangeHandler);
+      await dispatch(SharedTypes.CONNECTED_WALLET_ACTION, address, { root: true });
+    } catch (error) {
+      let message = 'Unknown Error'
+      if (error instanceof Error) {
+        message = error.message;
+      }
+      commit("setError", message);
+    }
+  },
+
+  async switchChainAction({ commit, dispatch, state }: {
+    commit: Commit,
+    dispatch: Dispatch,
+    state: SharedState,
+  }, chain: Chains) {
+    if (state.chain === chain) {
+      return;
+    }
+
+    if (state.account) {
+      await dispatch(SharedTypes.DISCONNECT_WALLET_ACTION, undefined, { root: true });
+    }
+
+    const network = chain === Chains.SOLANA
+      ? import.meta.env.VITE_SOLANA_NETWORK
+      : import.meta.env.VITE_ROOTSTOCK_NETWORK;
+
+    commit("setChain", chain);
+    commit("setNetwork", network);
+    commit("setPriceStats",
+      [
+        0,
+        0,
+        [],
+        0,
+      ]
+    );
+    commit("setPrice", [BASE_TOKENS[chain].symbol, 0]);
+    commit("setError", null);
+
+    await dispatch(SharedTypes.LOAD_WALLET_DATA_ACTION, undefined, { root: true });
+  },
 };
diff --git a/src/store/shared/consts.ts b/src/store/shared/consts.ts
index 46623de..27ed226 100644
--- a/src/store/shared/consts.ts
+++ b/src/store/shared/consts.ts
@@ -2,14 +2,18 @@ export enum SharedTypes {
   CONNECT_PHANTOM_ACTION = "sharedStore/connectPhantomAction",
   CONNECT_ENKRYPT_ACTION = "sharedStore/connectEnkryptAction",
   CONNECTED_WALLET_ACTION = "sharedStore/walletConnectedAction",
+  CONNECT_EVM_WALLET_ACTION = "sharedStore/connectEvmWalletAction",
   LOAD_WALLET_DATA_ACTION = "sharedStore/loadWalletDataAction",
   SET_ERROR_ACTION = "sharedStore/setError",
   DISCONNECT_WALLET_ACTION = "sharedStore/disconnectWallet",
   CONNECT_MODAL_ACTION = "sharedStore/connectModalAction",
+  SWITCH_CHAIN_ACTION = "sharedStore/switchChainAction",
   SET_PRICE = "sharedStore/setPrice",
 
   SET_ACCOUNT = "sharedStore/setAccount",
   SET_WALLET_TYPE = "sharedStore/setWalletType",
+  SET_CHAIN = "sharedStore/setChain",
+  SET_NETWORK = "sharedStore/setNetwork",
   SET_CONNECT_MODAL_VISIBLE = "sharedStore/setIsConnectModalVisible",
 
   IS_WALLET_CONNECTED_GETTER = "sharedStore/isWalletConnected",
@@ -21,4 +25,4 @@ export enum SharedTypes {
   PRICE_GETTER = "sharedStore/getPrice",
   PRICE_STATS_GETTER = "sharedStore/getPriceStats",
   IS_CONNECT_MODAL_VISIBLE_GETTER = "sharedStore/isConnectModalVisible",
-}
\ No newline at end of file
+}
diff --git a/src/store/shared/mutations.ts b/src/store/shared/mutations.ts
index 1bbf567..917b78e 100644
--- a/src/store/shared/mutations.ts
+++ b/src/store/shared/mutations.ts
@@ -47,6 +47,12 @@ export const mutations = {
   setProvider(state: SharedState, provider: any) {
     state.provider = provider;
   },
+  setChain(state: SharedState, chain: string) {
+    state.chain = chain;
+  },
+  setNetwork(state: SharedState, network: string) {
+    state.network = network;
+  },
   setBalance(state: SharedState, balance: number) {
     state.balance = balance;
   },
diff --git a/src/types/token.d.ts b/src/types/token.d.ts
index f614a86..10d0daf 100644
--- a/src/types/token.d.ts
+++ b/src/types/token.d.ts
@@ -4,4 +4,5 @@ export interface Token {
   image: string;
   symbol: string;
   price: number;
+  coinGeckoId?: string;
 }
diff --git a/src/utils/browser.ts b/src/utils/browser.ts
index 4db3162..efa8e82 100644
--- a/src/utils/browser.ts
+++ b/src/utils/browser.ts
@@ -1,4 +1,5 @@
 import platform from "platform";
+import { Chains } from "@/core/interfaces";
 
 export const BROWSER_NAMES = {
   chrome: "Chrome",
@@ -46,6 +47,39 @@ export const openSolscanExplorerTransaction = (id: string, cluster: string) => {
   window.open(`https://solscan.io/tx/${id}?cluster=${cluster}`, "_blank");
 };
 
+const ROOTSTOCK_EXPLORER =
+  import.meta.env.VITE_ROOTSTOCK_EXPLORER || "https://explorer.rootstock.io";
+
+export const openExplorerAddress = (
+  address: string,
+  chain: Chains,
+  cluster: string
+) => {
+  if (chain === Chains.SOLANA) {
+    openSolscanExplorerAddress(address, cluster);
+    return;
+  }
+
+  if (chain === Chains.ROOTSTOCK) {
+    window.open(`${ROOTSTOCK_EXPLORER}/address/${address}`, "_blank");
+  }
+};
+
+export const openExplorerTransaction = (
+  id: string,
+  chain: Chains,
+  cluster: string
+) => {
+  if (chain === Chains.SOLANA) {
+    openSolscanExplorerTransaction(id, cluster);
+    return;
+  }
+
+  if (chain === Chains.ROOTSTOCK) {
+    window.open(`${ROOTSTOCK_EXPLORER}/tx/${id}`, "_blank");
+  }
+};
+
 export const openContactSupport = () => {
   window.open(
     `mailto:support@enkrypt.com?subject=Enkrypt Staking Dapp Enquiry - ${__PACKAGE_VERSION__} - ${detectBrowser()} - ${detectOS()}`,
diff --git a/src/views/main/components/staking-item.vue b/src/views/main/components/staking-item.vue
index b1a6339..ae4a8c9 100644
--- a/src/views/main/components/staking-item.vue
+++ b/src/views/main/components/staking-item.vue
@@ -5,7 +5,7 @@
             <div class="staking-item__wrap-info">
                 <div class="staking-item__wrap-info-name">
                     <h4>{{ item.name }}</h4>
-                    <p v-if="item.apr">{{ (parseFloat(item.apr)).toFixed(2) }}% APR</p>
+                    <p v-if="item.apr">{{ (parseFloat(item.apr)).toFixed(2) }}% {{ metricLabel }}</p>
                 </div>
 
                 <div class="staking-item__wrap-info-price">
@@ -42,11 +42,11 @@
 </template>
   
 <script setup lang="ts">
-import { computed, PropType } from "vue";
+import { computed, PropType, toRefs } from "vue";
 import BaseButton from "@/components/base-button/index.vue";
 import WhiteWrapper from "@/components/white-wrapper/index.vue";
 import { useRouter } from "vue-router";
-import { StakingItemByChain } from "@/core/interfaces";
+import { StakingItemByChain, Chains } from "@/core/interfaces";
 import { use } from 'echarts/core';
 import { LineChart } from 'echarts/charts';
 import VChart from 'vue-echarts';
@@ -64,7 +64,7 @@ const store = useStore();
 const priceStats = computed(() => store.getters[SharedTypes.PRICE_STATS_GETTER]);
 const price = computed(() => store.getters[SharedTypes.PRICE_GETTER]);
 
-defineProps({
+const props = defineProps({
   item: {
     type: Object as PropType<StakingItemByChain>,
     default: () => ({}),
@@ -75,6 +75,11 @@ defineProps({
   },
 });
 
+const { item, isLast } = toRefs(props);
+const metricLabel = computed(() =>
+  item.value?.chainData?.id === Chains.ROOTSTOCK ? "ABI (Annual Backers Incentives)" : "APR"
+);
+
 use([SVGRenderer, LineChart, TooltipComponent, GridComponent]);
 
 const option = computed(() => {
@@ -129,7 +134,11 @@ const startAction = () => {
 
 const buyAction = () => {
   trackButtonsEvents(ButtonsActionEventType.MainScreenBuyButtonClicked);
-  window.open("https://ccswap.myetherwallet.com/?network=SOLANA&crypto=SOL&platform=enkrypt", '_blank');
+  const url =
+    item.value?.chainData?.id === Chains.ROOTSTOCK
+      ? "https://rootstock.io/rbtc/#get-rbtc"
+      : "https://ccswap.myetherwallet.com/?network=SOLANA&crypto=SOL&platform=enkrypt";
+  window.open(url, '_blank');
 };
 
 const swapAction = () => {};
@@ -280,4 +289,4 @@ const swapAction = () => {};
     }
   }
 }
-</style>
\ No newline at end of file
+</style>
diff --git a/src/views/main/index.vue b/src/views/main/index.vue
index f60a32c..c4f7083 100644
--- a/src/views/main/index.vue
+++ b/src/views/main/index.vue
@@ -1,10 +1,10 @@
 <template>
   <get-rewarded-banner />
   <staking-item
-    v-for="(item, index) in stakingItems"
+    v-for="(item, index) in filteredStakingItems"
     :key="index"
     :item="item"
-    :is-last="index == stakingItems.length - 1"
+    :is-last="index == filteredStakingItems.length - 1"
   ></staking-item>
 </template>
 
@@ -16,10 +16,16 @@ import { StakingTypes } from "@/store/modules/staking/consts";
 import { useStore } from "vuex";
 import { trackScreenEvents } from '@/libs/metrics';
 import { ScreenEventType } from '@/libs/metrics/types';
+import { SharedTypes } from "@/store/shared/consts";
 
 const store = useStore();
 
 const stakingItems = computed(() => store.getters[StakingTypes.STAKING_ITEMS_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const filteredStakingItems = computed(() => {
+  const item = stakingItems.value?.[activeChain.value];
+  return item ? [item] : [];
+});
 
 trackScreenEvents(ScreenEventType.MainScreenShown);
 </script>
diff --git a/src/views/portfolio/components/portfolio-item-validator.vue b/src/views/portfolio/components/portfolio-item-validator.vue
index c9139d1..f571299 100644
--- a/src/views/portfolio/components/portfolio-item-validator.vue
+++ b/src/views/portfolio/components/portfolio-item-validator.vue
@@ -25,35 +25,57 @@
               Balance
             </h3>
             <h3 class="portfolio-item-validator__info-amount">
-              {{ $filters.cryptoCurrencyFormat(item.balance / LAMPORTS_IN_SOL) }} <span>{{ token?.symbol }}</span>
+              <template v-if="isRootstock">
+                {{ Number(displayBalance || 0).toFixed(2) }}
+              </template>
+              <template v-else>
+                {{ $filters.cryptoCurrencyFormat(displayBalance) }}
+              </template>
+              <span>&nbsp;{{ token?.symbol }}</span>
             </h3>
+            <base-button
+              v-if="showRootstockUnstake"
+              class="portfolio-item-validator__rootstock-unstake"
+              title="Unstake"
+              :stroke="true"
+              :small="true"
+              :disabled="!item.isEnabled"
+              @click="rootstockUnstake"
+            />
           </div>
           <div class="col-2">
             <h3 class="text">
               Reward
             </h3>
             <h3 class="portfolio-item-validator__info-amount portfolio-item-validator__info-amount--flex" :class="amountClassObject">
-              {{ $filters.cryptoCurrencyFormat(item.reward) }} <span>{{ token?.symbol }}</span>
+               <template v-if="isRootstock">
+               {{ Number(item.reward || 0).toFixed(2) }} <span>&nbsp;{{ token?.symbol }}</span>
+              </template>
+               <template v-else>
+               {{ $filters.cryptoCurrencyFormat(item.reward) }} <span>{{ token?.symbol }}</span>
+              </template>
               <info-tooltip  :text="rewardInfoTooltipText" :is-big-text="true" :is-right="true" />
             </h3>
           </div>
         </div>
       </div>
       <div class="col-3 portfolio-item-validator__buttons">
-        <base-button v-if="item.status === Statuses.ACTIVE || item.status === Statuses.ACTIVATING"
-          :title="`${item.isEnabled ? 'Unstake' : 'Unstaking'}`"
-          :stroke="true"
-          :disabled="!item.isEnabled"
-          :small="true"
-          @click="() => unstakeAction(indexValue)"
-        />
-        <base-button v-if="item.status === Statuses.INACTIVE" 
-          :title="`${item.isEnabled ? 'Withdraw' : 'Withdrawing'}`"
-          :disabled="!item.isEnabled"
-          :stroke="true"
-          :small="true"
-          @click="withdrawAction(indexValue)"
-        />
+        <template v-if="!isRootstock">
+          <base-button v-if="item.status === Statuses.ACTIVE || item.status === Statuses.ACTIVATING"
+            :title="`${item.isEnabled ? 'Unstake' : 'Unstaking'}`"
+            :stroke="true"
+            :disabled="!item.isEnabled"
+            :small="true"
+            @click="() => unstakeAction(indexValue)"
+          />
+          <base-button v-if="item.status === Statuses.INACTIVE" 
+            :title="`${item.isEnabled ? 'Withdraw' : 'Withdrawing'}`"
+            :disabled="!item.isEnabled"
+            :stroke="true"
+            :small="true"
+            @click="withdrawAction(indexValue)"
+          />
+        </template>
         <!-- <base-button v-if="item.status === Statuses.EMPTY" title="Close" :stroke="true" :small="true" /> -->
         <!-- <base-button v-if="item.status === Statuses.INACTIVE" title="Stake" :small="true" /> -->
 
@@ -78,11 +100,11 @@ import MoreIcon from "@/icons/common/more-icon.vue";
 import InfoTooltip from "@/components/info-tooltip/index.vue";
 import { onClickOutside } from "@vueuse/core";
 import { useRouter } from "vue-router";
-import { Statuses, Token } from "@/core/interfaces";
+import { Chains, Statuses, Token } from "@/core/interfaces";
 import { StakingTypes } from "@/store/modules/staking/consts";
 import { useStore } from "vuex";
 import { SharedTypes } from "@/store/shared/consts";
-import { openSolscanExplorerAddress } from "@/utils/browser";
+import { openExplorerAddress } from "@/utils/browser";
 import { LAMPORTS_IN_SOL } from "@/core/constants";
 import { trackButtonsEvents } from '@/libs/metrics';
 import { ButtonsActionEventType } from '@/libs/metrics/types';
@@ -114,6 +136,15 @@ const props = defineProps({
 
 const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
 const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const isRootstock = computed(() => activeChain.value === Chains.ROOTSTOCK);
+const displayBalance = computed(() => {
+  if (isRootstock.value) {
+    return props.item.balance;
+  }
+
+  return props.item.balance / LAMPORTS_IN_SOL;
+});
+const showRootstockUnstake = computed(() => isRootstock.value && props.item.balance > 0);
 
 const amountClassObject = computed(() => ({
   'portfolio-item-validator__info-amount--green': props.item.reward > 0,
@@ -142,7 +173,7 @@ const infoTooltipText = computed(() => {
   return "Your SOL is currently staked with a validator. You'll need to unstake to access these funds"
 });
 
-const rewardInfoTooltipText = "Solana adds staking rewards at the end of each epoch. An epoch on Solana typically lasts around two days. If you have a stake active throughout an epoch, you'll see your rewards credited approximately <b>every two days</b>.<br />These rewards are automatically compounded if you choose to keep them staked, so over time your stake grows as long as you maintain your delegation.";
+const rewardInfoTooltipText = isRootstock ? "Rootstock collective adds rewards based on your stRIF allocations to innovative Builders. Your allocations shape their rewards, and you retain full ownership and access to your stRIF while earning a portion of their rewards. For more information check the <a href=\"https://wiki.rootstockcollective.xyz/\" target=\"_blank\">Whitepaper</a>." :"Solana adds staking rewards at the end of each epoch. An epoch on Solana typically lasts around two days. If you have a stake active throughout an epoch, you'll see your rewards credited approximately <b>every two days</b>.<br />These rewards are automatically compounded if you choose to keep them staked, so over time your stake grows as long as you maintain your delegation.";
 
 const validator = computed(() => {
   return validators[props.item.provider][activeChain.value];
@@ -186,9 +217,18 @@ const withdrawAction = async (index: number) => {
   router.push({ name: 'withdraw' });
 };
 
+const rootstockUnstake = async () => {
+  if (!showRootstockUnstake.value) {
+    return;
+  }
+
+  trackButtonsEvents(ButtonsActionEventType.PortfolioScreenUnstakeButtonButtoClicked);
+  await store.dispatch(StakingTypes.ROOTSTOCK_UNSTAKE_ACTION, props.item.balance);
+};
+
 const detailsAction = () => {
   trackButtonsEvents(ButtonsActionEventType.PortfolioScreenViewInExploreButtonClicked);
-  openSolscanExplorerAddress(props.item.stakeAccount, network.value);
+  openExplorerAddress(props.item.stakeAccount, activeChain.value, network.value);
 };
 
 </script>
@@ -473,5 +513,9 @@ const detailsAction = () => {
       display: block;
     }
   }
+
+  &__rootstock-unstake {
+    margin-top: 8px;
+  }
 }
 </style>
diff --git a/src/views/portfolio/components/portfolio-item.vue b/src/views/portfolio/components/portfolio-item.vue
index 9bfcb90..e19add8 100644
--- a/src/views/portfolio/components/portfolio-item.vue
+++ b/src/views/portfolio/components/portfolio-item.vue
@@ -12,7 +12,7 @@
               <div class="col-4">
                 <h6 class="portfolio-item__info-label">Total staked</h6>
                 <p class="portfolio-item__info-value">
-                  {{ $filters.cryptoCurrencyFormat(item.totalStaked / LAMPORTS_IN_SOL) }} <span>{{ item.baseToken?.symbol }}</span>
+                  {{ totalStakedDisplay }} <span :class="{ 'portfolio-item__token--exact': isRootstock }">{{ totalStakedSymbol }}</span>
                 </p>
                 <p v-if="prices?.[BASE_TOKENS[activeChain].symbol]" class="portfolio-item__info-amount">
                   ~{{ $filters.currencyFormat(totalStakedUsd, "USD") }}
@@ -24,18 +24,31 @@
                   <info-tooltip  :text="infoTooltipText" :is-big-text="true" />
                 </h6>
                 <p class="portfolio-item__info-value portfolio-item__info-value--green">
-                  {{ $filters.cryptoCurrencyFormat(item.totalRewards) }} <span>{{ item.baseToken?.symbol }}</span>
+                  {{ totalRewardsDisplay }} <span>{{ item.baseToken?.symbol }}</span>
                 </p>
                 <p class="portfolio-item__info-amount">
                   ~{{ $filters.currencyFormat(totalRewardsUsd, "USD") }}
                 </p>
+                <div v-if="isRootstock" @click.stop>
+                  <base-button
+                    title="Claim my rewards"
+                    :small="true"
+                    :secondary="true"
+                    :disabled="!canClaimRewards"
+                    :loading="isLoading"
+                    :action="onClaimRewardsClicked"
+                  />
+                </div>
               </div>
               <div class="col-4">
-                <h6 class="portfolio-item__info-label">Avg. Yield</h6>
+                <h6 v-if="isRootstock" class="portfolio-item__info-label">Avg.Yield (ABI%)</h6>
+                <h6 v-else class="portfolio-item__info-label">Avg. Yield</h6>
                 <p class="portfolio-item__info-value portfolio-item__info-value--regular">
                   ~{{ $filters.percentFormat(stakingItems[activeChain].apr) }}
                 </p>
-                <p class="portfolio-item__info-amount">&nbsp;</p>
+                <p v-if="isRootstock" class="portfolio-item__info-amount">&nbsp;
+                  <info-tooltip text="Claim your rewards directly to your wallet. Claimed rewards are transferred immediately, and your unclaimed balance resets." :is-big-text="true" :is-right="true" />
+                </p>
               </div>
             </div>
           </div>
@@ -52,22 +65,23 @@
     </div>
     <Transition name="fade">
       <div v-show="isOpen" class="portfolio-item__detail">
-        <div class="row justify-content-beetwen align-items-center portfolio-item__info-header">
-          <div class="col-9">
-            <div class="row justify-content-beetwen align-items-center">
-              <div class="col-6">
-                <p class="portfolio-item__info-header-label">Validator</p>
-              </div>
-              <div class="col-2">
-                <p class="portfolio-item__info-header-label portfolio-item__info-header-label--right">Balance</p>
-              </div>
-              <div class="col-2">
-                <p class="portfolio-item__info-header-label portfolio-item__info-header-label--right">Reward</p>
+        <template v-if="!isRootstock">
+          <div class="row justify-content-beetwen align-items-center portfolio-item__info-header">
+            <div class="col-9">
+              <div class="row justify-content-beetwen align-items-center">
+                <div class="col-6">
+                  <p class="portfolio-item__info-header-label">Validator</p>
+                </div>
+                <div class="col-2">
+                  <p class="portfolio-item__info-header-label portfolio-item__info-header-label--right">Balance</p>
+                </div>
+                <div class="col-2">
+                  <p class="portfolio-item__info-header-label portfolio-item__info-header-label--right">Reward</p>
+                </div>
               </div>
             </div>
-          </div>
-        </div>      
-
+          </div>      
+        </template>
         <portfolio-item-validator
           v-for="(validator, index) in item.items"
           :key="index"
@@ -85,7 +99,7 @@
 import { computed, PropType, ref } from "vue";
 import Expand from "@/icons/common/expand.vue";
 import WhiteWrapper from "@/components/white-wrapper/index.vue";
-import { PortfolioByChain } from "@/core/interfaces";
+import { Chains, PortfolioByChain } from "@/core/interfaces";
 import PortfolioItemValidator from "./portfolio-item-validator.vue";
 import BaseButton from "@/components/base-button/index.vue";
 import { useRouter } from "vue-router";
@@ -94,11 +108,18 @@ import { SharedTypes } from "@/store/shared/consts";
 import { BASE_TOKENS } from "@/core/constants";
 import { LAMPORTS_IN_SOL } from "@/core/constants";
 import { StakingTypes } from "@/store/modules/staking/consts";
+import { cryptoCurrencyFormat } from "@/utils/filters";
 import { trackButtonsEvents } from '@/libs/metrics';
 import { ButtonsActionEventType } from '@/libs/metrics/types';
 import InfoTooltip from "@/components/info-tooltip/index.vue";
 
-const infoTooltipText = "Solana adds staking rewards at the end of each epoch. An epoch on Solana typically lasts around two days. If you have a stake active throughout an epoch, you'll see your rewards credited approximately <b>every two days</b>.<br />These rewards are automatically compounded if you choose to keep them staked, so over time your stake grows as long as you maintain your delegation.";
+const infoTooltipText = computed(() => {
+  if (activeChain.value === Chains.ROOTSTOCK) {
+    return "Rootstock collective adds rewards based on your stRIF allocations to innovative Builders. Your allocations shape their rewards, and you retain full ownership and access to your stRIF while earning a portion of their rewards. For more information check the <a href=\"https://wiki.rootstockcollective.xyz/\" target=\"_blank\">Whitepaper</a>.";
+  }
+
+  return "Solana adds staking rewards at the end of each epoch. An epoch on Solana typically lasts around two days. If you have a stake active throughout an epoch, you'll see your rewards credited approximately <b>every two days</b>.<br />These rewards are automatically compounded if you choose to keep them staked, so over time your stake grows as long as you maintain your delegation.";
+});
 
 const router = useRouter();
 const store = useStore();
@@ -121,15 +142,32 @@ isOpen.value = props.isFirst;
 const prices = computed(() => store.getters[SharedTypes.PRICE_GETTER]);
 const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
 const stakingItems = computed(() => store.getters[StakingTypes.STAKING_ITEMS_GETTER]);
+const isLoading = computed(() => store.getters[StakingTypes.IS_LOADING_GETTER]);
+const isRootstock = computed(() => activeChain.value === Chains.ROOTSTOCK);
 
+const totalStakedAmount = computed(() => {
+  const divider = activeChain.value === Chains.ROOTSTOCK ? 1 : LAMPORTS_IN_SOL;
+  return props.item.totalStaked / divider;
+});
+const totalStakedDisplay = computed(() => {
+  if (activeChain.value === Chains.ROOTSTOCK) {
+    return Number(totalStakedAmount.value || 0).toFixed(2);
+  }
+  return cryptoCurrencyFormat(totalStakedAmount.value);
+});
+const totalStakedSymbol = computed(() => {
+  return activeChain.value === Chains.ROOTSTOCK ? "stRIF" : (props.item.baseToken?.symbol ?? "");
+});
 const totalStakedUsd = computed(() => {
   const price = prices.value?.[BASE_TOKENS[activeChain.value].symbol] || 0;
-  return (props.item.totalStaked / LAMPORTS_IN_SOL) * price;
+  return totalStakedAmount.value * price;
 });
 const totalRewardsUsd = computed(() => {
   const price = prices.value?.[BASE_TOKENS[activeChain.value].symbol] || 0;
   return props.item.totalRewards * price;
 });
+const totalRewardsDisplay = computed(() => Number(props.item.totalRewards || 0).toFixed(2));
+const canClaimRewards = computed(() => isRootstock.value && props.item.totalRewards > 0);
 
 const toggle = () => {
   isOpen.value = !isOpen.value;
@@ -140,6 +178,13 @@ const onStakeMoreClicked = (e: Event) => {
   e.stopPropagation();
   router.push({ name: "stake" });
 }
+
+const onClaimRewardsClicked = async () => {
+  if (!canClaimRewards.value || isLoading.value) {
+    return;
+  }
+  await store.dispatch(StakingTypes.CLAIM_ROOTSTOCK_REWARDS_ACTION);
+}
 </script>
 
 <style lang="less" scoped>
@@ -288,6 +333,12 @@ const onStakeMoreClicked = (e: Event) => {
     }
   }
 
+  &__token {
+    &--exact {
+      text-transform: none !important;
+    }
+  }
+
   &__arrow {
     margin-left: 4px;
     .transition(all, 0.3s);
diff --git a/src/views/stake-confirm/components/stake-confirm-process.vue b/src/views/stake-confirm/components/stake-confirm-process.vue
index e56c663..571f3e6 100644
--- a/src/views/stake-confirm/components/stake-confirm-process.vue
+++ b/src/views/stake-confirm/components/stake-confirm-process.vue
@@ -2,8 +2,8 @@
   <div v-if="isDone" class="stake-confirm-process">
     <div class="stake-confirm-process__stack">
       <done-animation />
-      <h3>SOL staked!</h3>
-      <p>Your SOL will begin earning rewards in the next couple days once the stake account is activated.</p>
+      <h3>{{ tokenSymbol }} staked!</h3>
+      <p>Your {{ tokenSymbol }} will begin earning rewards in the next couple days once the stake account is activated.</p>
       <base-button title="View details" :action="detailsAction" :stroke="true" :small="true" />
     </div>
     <div class="stake-confirm-process__button">
@@ -23,8 +23,27 @@
   </div>
   <div v-else class="stake-confirm-process stake-confirm-process--center">
     <spinner-animation />
-    <h3>Staking SOL</h3>
-    <p>Creating your staking account and delegating your SOL to P2P.org validator.</p>
+    <h3>Staking {{ tokenSymbol }}</h3>
+    <p>{{ stakingDescription }}</p>
+    <div v-if="activeChain === Chains.ROOTSTOCK" class="stake-confirm-process__timeline">
+      <div
+        v-for="(step, index) in rootstockFlowSteps"
+        :key="step.id"
+        class="stake-confirm-process__timeline-item"
+      >
+        <div class="stake-confirm-process__timeline-indicator" :class="step.status">
+          {{ step.status === "done" ? "v" : index + 1 }}
+        </div>
+        <div class="stake-confirm-process__timeline-content">
+          <p class="stake-confirm-process__timeline-title" :class="`stake-confirm-process__timeline-title--${step.status}`">
+            {{ step.title }}
+          </p>
+          <p class="stake-confirm-process__timeline-status" :class="`stake-confirm-process__timeline-status--${step.status}`">
+            {{ formatStepStatus(step.status) }}
+          </p>
+        </div>
+      </div>
+    </div>
     <base-button v-if="stakingAccountTxId" title="View details" :action="detailsAction" :stroke="true" :small="true" />
   </div>
 </template>
@@ -40,15 +59,44 @@ import { computed } from "vue";
 import { StakingTypes } from "@/store/modules/staking/consts";
 import { useStore } from "vuex";
 import { SharedTypes } from "@/store/shared/consts";
-import { openSolscanExplorerTransaction, openContactSupport } from "@/utils/browser";
+import { openExplorerTransaction, openContactSupport } from "@/utils/browser";
 import { trackButtonsEvents, trackScreenEvents } from '@/libs/metrics';
 import { ButtonsActionEventType, ScreenEventType } from '@/libs/metrics/types';
+import { BASE_TOKENS } from "@/core/constants/index";
+import { Chains } from "@/core/interfaces";
 
 const router = useRouter();
 const store = useStore();
 
 const stakingAccountTxId = computed(() => store.getters[StakingTypes.TX_ID_GETTER]);
 const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const tokenSymbol = computed(() => BASE_TOKENS[activeChain.value]?.symbol?.toUpperCase?.() ?? "");
+const rootstockStakeFlowSteps = computed(() => store.getters[StakingTypes.ROOTSTOCK_STAKE_FLOW_STEPS_GETTER]);
+const rootstockFlowSteps = computed(() => [
+  {
+    id: "approve",
+    title: "Allow RIF spending",
+    status: rootstockStakeFlowSteps.value?.approve ?? "pending",
+  },
+  {
+    id: "stake",
+    title: "Stake RIF",
+    status: rootstockStakeFlowSteps.value?.stake ?? "pending",
+  },
+  {
+    id: "backBuilders",
+    title: "Back Top Builders",
+    status: rootstockStakeFlowSteps.value?.backBuilders ?? "pending",
+  },
+]);
+const stakingDescription = computed(() => {
+  if (activeChain.value === Chains.ROOTSTOCK) {
+    return `Processing your ${tokenSymbol.value} stake on Rootstock. This may take a moment.`;
+  }
+
+  return `Creating your staking account and delegating your ${tokenSymbol.value} to P2P.org validator.`;
+});
 
 const props = defineProps({
   isDone: {
@@ -67,6 +115,16 @@ watch(() => props.isError, (newValue) => {
   }
 });
 
+const formatStepStatus = (status: string) => {
+  if (status === "done") {
+    return "Done";
+  }
+  if (status === "in_progress") {
+    return "In progress";
+  }
+  return "Pending";
+};
+
 const backAction = () => {
   trackButtonsEvents(ButtonsActionEventType.StakingConfirmScreenErrorBackButtonClicked);
   router.push({ name: "stake" });
@@ -74,7 +132,7 @@ const backAction = () => {
 
 const detailsAction = () => {
   trackButtonsEvents(ButtonsActionEventType.StakingConfirmScreenDetailsButtonClicked);
-  openSolscanExplorerTransaction(stakingAccountTxId.value, network.value);
+  openExplorerTransaction(stakingAccountTxId.value, activeChain.value, network.value);
 };
 
 const doneAction = () => {
@@ -159,5 +217,93 @@ const doneAction = () => {
 
     });
   }
+
+  &__timeline {
+    margin-top: 16px;
+    width: 100%;
+    max-width: 420px;
+    margin-left: auto;
+    margin-right: auto;
+    text-align: left;
+  }
+
+  &__timeline-item {
+    display: flex;
+    align-items: flex-start;
+    margin-bottom: 10px;
+  }
+
+  &__timeline-indicator {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    border: 1px solid @gray016;
+    color: @gray016;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-right: 10px;
+    font-size: 12px;
+    font-weight: 600;
+
+    &.in_progress {
+      border-color: @accent;
+      color: @accent;
+    }
+
+    &.done {
+      border-color: @success;
+      color: @success;
+    }
+  }
+
+  &__timeline-content {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 2px;
+  }
+
+  &__timeline-title {
+    .caption__Regular();
+    margin: 0;
+    color: @primaryLabel;
+    padding: 0 !important;
+    text-align: left !important;
+  }
+
+  &__timeline-status {
+    .caption__Regular();
+    margin: 0;
+    color: @secondaryLabel;
+    padding: 0 !important;
+    text-align: left !important;
+
+    &--pending {
+      color: @secondaryLabel;
+    }
+
+    &--in_progress {
+      color: @accent;
+    }
+
+    &--done {
+      color: @success;
+    }
+  }
+
+  &__timeline-title {
+    &--pending {
+      color: @primaryLabel;
+    }
+
+    &--in_progress {
+      color: @accent;
+    }
+
+    &--done {
+      color: @success;
+    }
+  }
 }
 </style>
diff --git a/src/views/stake-confirm/index.vue b/src/views/stake-confirm/index.vue
index 25c506a..b9ea419 100644
--- a/src/views/stake-confirm/index.vue
+++ b/src/views/stake-confirm/index.vue
@@ -9,6 +9,7 @@
             :account="walletAccount"
             title="From"
             :amount="walletBalance"
+            :token="nativeToken"
           />
         </div>
 
@@ -21,7 +22,7 @@
         <arrow-down-big />
       </div>
 
-      <div class="stake-confirm__block">
+      <div v-if="showValidatorInfo" class="stake-confirm__block">
         <stake-confirm-validator-item :validator="validators[Providers.p2p][activeChain]" />
       </div>
 
@@ -77,7 +78,7 @@ const isLoading = ref<boolean>(false);
 const isSend = ref<boolean>(false);
 const isSendDone = ref<boolean>(false);
 const isError = ref<boolean>(false);
-const nativeToken = ref<Token>(BASE_TOKENS[Chains.SOLANA]);
+const nativeToken = computed<Token>(() => BASE_TOKENS[activeChain.value]);
 
 const walletBalance = computed(() => store.getters[SharedTypes.WALLET_BALANCE_GETTER]);
 const amountValue = computed(() => store.getters[StakingTypes.STAKING_AMOUNT_GETTER]);
@@ -85,6 +86,7 @@ const walletAccount = computed(() => store.getters[SharedTypes.WALLET_ACCOUNT_GE
 const stakingData = computed(() => store.getters[StakingTypes.STAKING_DATA_GETTER]);
 const validators = computed(() => store.getters[StakingTypes.VALIDATORS_GETTER]);
 const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const showValidatorInfo = computed(() => activeChain.value === Chains.SOLANA);
 const error = computed(() => store.getters[StakingTypes.ERROR_GETTER]);
 const fee = computed(() => store.getters[StakingTypes.STAKING_FEE_GETTER]);
 
@@ -102,6 +104,19 @@ const nextAction = async () => {
   trackScreenEvents(ScreenEventType.StackingProcessScreenShown);
 
   try {
+    if (activeChain.value === Chains.ROOTSTOCK) {
+      const result = await store.dispatch(StakingTypes.START_STAKE_ACTION, null);
+      if (result) {
+        isSendDone.value = true;
+        trackScreenEvents(ScreenEventType.StackingDoneScreenShown);
+      }
+      return;
+    }
+
+    if (!stakingData.value) {
+      throw new Error("Staking data is missing");
+    }
+
     const decodedTransaction = Buffer.from(stakingData.value.unsignedTransaction, 'base64');
     const transaction = Transaction.from(decodedTransaction);
     const signedTransaction = await wallet.signTransaction.value?.(transaction);
diff --git a/src/views/stake-enter-amount/index.vue b/src/views/stake-enter-amount/index.vue
index 4b7c4ab..528a7d6 100644
--- a/src/views/stake-enter-amount/index.vue
+++ b/src/views/stake-enter-amount/index.vue
@@ -14,17 +14,51 @@
         @update:amount="inputAmount"
       />
 
-      <validator-info class="stake-enter-amount__validator" :validator="validators[Providers.p2p][activeChain]" />
+      <validator-info
+        v-if="showValidatorInfo"
+        class="stake-enter-amount__validator"
+        :validator="validators[Providers.p2p][activeChain]"
+      />
+      <p v-if="isRootstock" class="stake-enter-amount__rootstock-note">
+        The staking amount will be automatically distributed among top builders in Rootstock ecosystem. You as
+        a backer will automatically earn the yield shared by builders in Rootstock ecosystem. The staking process will
+        ask you to approve total of 3 transaction (approve RIF spending, staking, backing builders) to complete the staking process.
+      </p>
+      <div v-if="isRootstock" class="stake-enter-amount__timeline">
+        <div
+          v-for="(step, index) in rootstockFlowSteps"
+          :key="step.id"
+          class="stake-enter-amount__timeline-item"
+        >
+          <div
+            class="stake-enter-amount__timeline-indicator"
+            :class="step.status"
+          >
+            {{ step.status === "done" ? "v" : index + 1 }}
+          </div>
+          <div class="stake-enter-amount__timeline-content">
+            <p class="stake-enter-amount__timeline-title">{{ step.title }}</p>
+            <!-- <p class="stake-enter-amount__timeline-status">{{ formatStepStatus(step.status) }}</p> -->
+          </div>
+        </div>
+      </div>
     </div>
 
     <buttons-block :is-space="true">
       <div class="stake-enter-amount__estimated">
-        <p class="stake-enter-amount__estimated-label">Estimated Balance in 1 year</p>
+        <p class="stake-enter-amount__estimated-label">
+          {{ estimatedLabel }}
+        </p>
 
         <p class="stake-enter-amount__estimated-coast">
-          {{ $filters.cryptoCurrencyFormat(returns) }} <span>{{ BASE_TOKENS[activeChain].symbol }}</span>
+          <template v-if="isRootstock">
+            {{ abiValue.toFixed(2) }}% ABI
+          </template>
+          <template v-else>
+            {{ $filters.cryptoCurrencyFormat(returns) }} <span>{{ BASE_TOKENS[activeChain].symbol }}</span>
+          </template>
         </p>
-        <p class="stake-enter-amount__estimated-fiat">
+        <p v-if="!isRootstock" class="stake-enter-amount__estimated-fiat">
           ~{{ $filters.currencyFormat(returnsUSD, "USD") }}
         </p>
       </div>
@@ -64,10 +98,20 @@ const walletBalance = computed(() => store.getters[SharedTypes.WALLET_BALANCE_GE
 const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
 const prices = computed(() => store.getters[SharedTypes.PRICE_GETTER]);
 const validators = computed(() => store.getters[StakingTypes.VALIDATORS_GETTER]);
+const stakingItems = computed(() => store.getters[StakingTypes.STAKING_ITEMS_GETTER]);
 const walletAccount = computed(() => store.getters[SharedTypes.WALLET_ACCOUNT_GETTER]);
 const isLoading = computed(() => store.getters[StakingTypes.IS_STAKING_LOADING_GETTER]);
+const isRootstock = computed(() => activeChain.value === Chains.ROOTSTOCK);
+const rootstockStakeFlowSteps = computed(() => store.getters[StakingTypes.ROOTSTOCK_STAKE_FLOW_STEPS_GETTER]);
+const abiValue = computed(() => {
+  const raw = stakingItems.value?.[activeChain.value]?.apr ?? "0";
+  const parsed = parseFloat(String(raw));
+  return Number.isFinite(parsed) ? parsed : 0;
+});
+const estimatedLabel = computed(() => (isRootstock.value ? "ABI" : "Estimated Balance in 1 year"));
 const returns = computed(() => {
-  return amount.value * (1 + validators.value[Providers.p2p][activeChain.value].apy);
+  const apy = Number(validators.value[Providers.p2p][activeChain.value].apy || 0);
+  return amount.value * (1 + apy);
 });
 const returnsUSD = computed(() => {
   const value = returns.value || 0;
@@ -76,12 +120,33 @@ const returnsUSD = computed(() => {
 });
 
 const amount = ref<number>(0);
-const nativeToken = ref<Token>(BASE_TOKENS[Chains.SOLANA]);
+const nativeToken = computed<Token>(() => BASE_TOKENS[activeChain.value]);
+const showValidatorInfo = computed(() => activeChain.value === Chains.SOLANA);
 const minAmount = ref<number>(1.003);
+const rootstockFlowSteps = computed(() => [
+  {
+    id: "approve",
+    title: "Allow RIF spending",
+    status: rootstockStakeFlowSteps.value?.approve ?? "pending",
+  },
+  {
+    id: "stake",
+    title: "Stake RIF",
+    status: rootstockStakeFlowSteps.value?.stake ?? "pending",
+  },
+  {
+    id: "backBuilders",
+    title: "Back Top Builders",
+    status: rootstockStakeFlowSteps.value?.backBuilders ?? "pending",
+  },
+]);
 
 trackScreenEvents(ScreenEventType.StackingScreenShown);
 
 onMounted(async () => {
+  if (isRootstock.value) {
+    store.commit(StakingTypes.RESET_ROOTSTOCK_STAKE_FLOW_STEPS);
+  }
    await store.dispatch(
     StakingTypes.SET_ERROR_STATE, 
     null,
@@ -130,6 +195,16 @@ const inputAmount = (newVal: string) => {
   store.commit(StakingTypes.SET_STAKING_AMOUNT, newVal);
 };
 
+const formatStepStatus = (status: string) => {
+  if (status === "done") {
+    return "Done";
+  }
+  if (status === "in_progress") {
+    return "In progress";
+  }
+  return "Pending";
+};
+
 </script>
 
 <style lang="less" scoped>
@@ -160,6 +235,64 @@ const inputAmount = (newVal: string) => {
   &__stack {
     width: 100%;
   }
+  
+  &__rootstock-note {
+    .caption__Regular();
+    margin: 12px 0 0 0;
+    color: @secondaryLabel;
+  }
+
+  &__timeline {
+    margin-top: 12px;
+  }
+
+  &__timeline-item {
+    display: flex;
+    align-items: center;
+    margin-bottom: 10px;
+  }
+
+  &__timeline-indicator {
+    width: 24px;
+    height: 24px;
+    border-radius: 50%;
+    border: 1px solid @gray016;
+    color: @gray016;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin-right: 10px;
+    font-size: 12px;
+    font-weight: 600;
+
+    &.in_progress {
+      border-color: @accent;
+      color: @accent;
+    }
+
+    &.done {
+      border-color: @success;
+      color: @success;
+    }
+  }
+
+  &__timeline-content {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  }
+
+  &__timeline-title {
+    .caption__Regular();
+    margin: 0;
+    color: @primaryLabel;
+  }
+
+  &__timeline-status {
+    .caption__Regular();
+    margin: 0;
+    color: @secondaryLabel;
+  }
 
   &__estimated {
     margin-right: 16px;
diff --git a/src/views/unstake/components/unstake-process.vue b/src/views/unstake/components/unstake-process.vue
index 81044b9..f34b163 100644
--- a/src/views/unstake/components/unstake-process.vue
+++ b/src/views/unstake/components/unstake-process.vue
@@ -2,7 +2,7 @@
   <div v-if="isDone" class="unstake-process">
     <div class="unstake-process__stack">
       <done-animation />
-      <h3>SOL Unstaked</h3>
+      <h3>{{ tokenSymbol }} Unstaked</h3>
       <p>You will be able to withdraw your stake in the next couple days once the stake account becomes unstaked.</p>
       <base-button title="View details" :action="detailsAction" :stroke="true" :small="true" />
     </div>
@@ -23,8 +23,8 @@
   </div>
   <div v-else class="unstake-process unstake-process--center">
     <spinner-animation />
-    <h3>Unstaking SOL</h3>
-    <p>We are starting the process to unstake your SOL.</p>
+    <h3>Unstaking {{ tokenSymbol }}</h3>
+    <p>We are starting the process to unstake your {{ tokenSymbol }}.</p>
     <base-button v-if="unstakingAccountTxId" title="View details" :action="detailsAction" :stroke="true" :small="true" />
   </div>
 </template>
@@ -40,7 +40,8 @@ import { computed } from "vue";
 import { StakingTypes } from "@/store/modules/staking/consts";
 import { useStore } from "vuex";
 import { SharedTypes } from "@/store/shared/consts";
-import { openSolscanExplorerTransaction, openContactSupport } from "@/utils/browser";
+import { openExplorerTransaction, openContactSupport } from "@/utils/browser";
+import { BASE_TOKENS } from "@/core/constants/index";
 import { trackButtonsEvents, trackScreenEvents } from '@/libs/metrics';
 import { ButtonsActionEventType, ScreenEventType } from '@/libs/metrics/types';
 
@@ -48,6 +49,8 @@ const store = useStore();
 const router = useRouter();
 
 const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const tokenSymbol = computed(() => BASE_TOKENS[activeChain.value]?.symbol?.toUpperCase?.() ?? "");
 const unstakingAccountTxId = computed(() => store.getters[StakingTypes.TX_ID_GETTER]);
 
 const props = defineProps({
@@ -74,7 +77,7 @@ const backAction = () => {
 
 const detailsAction = () => {
   trackButtonsEvents(ButtonsActionEventType.UnstakeScreenDetailsButtonClicked);
-  openSolscanExplorerTransaction(unstakingAccountTxId.value, network.value);
+  openExplorerTransaction(unstakingAccountTxId.value, activeChain.value, network.value);
 };
 
 const doneAction = () => {
diff --git a/src/views/withdraw/components/withdraw-process.vue b/src/views/withdraw/components/withdraw-process.vue
index cf4e93f..e0b8492 100644
--- a/src/views/withdraw/components/withdraw-process.vue
+++ b/src/views/withdraw/components/withdraw-process.vue
@@ -2,8 +2,8 @@
   <div v-if="isDone" class="withdraw-process">
     <div class="withdraw-process__stack">
       <done-animation />
-      <h3>SOL Withdrawn</h3>
-      <p>Your SOL has been withdrawn.</p>
+      <h3>{{ tokenSymbol }} Withdrawn</h3>
+      <p>Your {{ tokenSymbol }} has been withdrawn.</p>
       <base-button title="View details" :action="detailsAction" :stroke="true" :small="true" />
     </div>
     <div class="withdraw-process__button">
@@ -23,8 +23,8 @@
   </div>
   <div v-else class="withdraw-process withdraw-process--center">
     <spinner-animation />
-    <h3>Withdrawing SOL</h3>
-    <p>We are withdrawing your SOL from this stake account.</p>
+    <h3>Withdrawing {{ tokenSymbol }}</h3>
+    <p>We are withdrawing your {{ tokenSymbol }} from this stake account.</p>
     <base-button v-if="withdrawTxId" title="View details" :action="detailsAction" :stroke="true" :small="true" />
   </div>
 </template>
@@ -40,14 +40,17 @@ import { StakingTypes } from "@/store/modules/staking/consts";
 import { useStore } from "vuex";
 import { computed } from "vue";
 import { SharedTypes } from "@/store/shared/consts";
-import { openSolscanExplorerTransaction, openContactSupport } from "@/utils/browser";
+import { openExplorerTransaction, openContactSupport } from "@/utils/browser";
 import { trackButtonsEvents, trackScreenEvents } from '@/libs/metrics';
 import { ButtonsActionEventType, ScreenEventType } from '@/libs/metrics/types';
+import { BASE_TOKENS } from "@/core/constants/index";
 
 const store = useStore();
 const router = useRouter();
 
 const network = computed(() => store.getters[SharedTypes.NETWORK_GETTER]);
+const activeChain = computed(() => store.getters[SharedTypes.CHAIN_GETTER]);
+const tokenSymbol = computed(() => BASE_TOKENS[activeChain.value]?.symbol?.toUpperCase?.() ?? "");
 const withdrawTxId = computed(() => store.getters[StakingTypes.TX_ID_GETTER]);
 
 const props = defineProps({
@@ -74,7 +77,7 @@ const backAction = () => {
 
 const detailsAction = () => {
   trackButtonsEvents(ButtonsActionEventType.WithdrawScreenDetailsButtonClicked);
-  openSolscanExplorerTransaction(withdrawTxId.value, network.value);
+  openExplorerTransaction(withdrawTxId.value, activeChain.value, network.value);
 };
 
 const doneAction = () => {