diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/ConfirmTransaction.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/ConfirmTransaction.tsx
index 2b443a871..548657a3a 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/ConfirmTransaction.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/ConfirmTransaction.tsx
@@ -5,11 +5,8 @@ import { useTranslation } from 'react-i18next';
 import { Layout } from '../Layout';
 import { useViewsFlowContext } from '@providers/ViewFlowProvider';
 import styles from './ConfirmTransaction.module.scss';
-import { Wallet } from '@lace/cardano';
 import { useWalletStore } from '@stores';
 import { useDisallowSignTx, useSignWithHardwareWallet, useOnBeforeUnload } from './hooks';
-import { getTxType } from './utils';
-import { ConfirmTransactionContent } from './ConfirmTransactionContent';
 import { TX_CREATION_TYPE_KEY, TxCreationType } from '@providers/AnalyticsProvider/analyticsTracker';
 import { txSubmitted$ } from '@providers/AnalyticsProvider/onChain';
 import { useAnalyticsContext } from '@providers';
@@ -21,6 +18,7 @@ import { DAPP_CHANNELS } from '@src/utils/constants';
 import { of, take } from 'rxjs';
 import { runtime } from 'webextension-polyfill';
 import { Skeleton } from 'antd';
+import { DappTransactionContainer } from './DappTransactionContainer';
 
 export const ConfirmTransaction = (): React.ReactElement => {
   const { t } = useTranslation();
@@ -29,22 +27,11 @@ export const ConfirmTransaction = (): React.ReactElement => {
     setDappInfo,
     signTxRequest: { request: req, set: setSignTxRequest }
   } = useViewsFlowContext();
-
   const { walletType, isHardwareWallet } = useWalletStore();
   const analytics = useAnalyticsContext();
-  const [confirmTransactionError, setConfirmTransactionError] = useState(false);
+  const [confirmTransactionError] = useState(false);
   const disallowSignTx = useDisallowSignTx(req);
   const { isConfirmingTx, signWithHardwareWallet } = useSignWithHardwareWallet(req);
-  const [txType, setTxType] = useState<Wallet.Cip30TxType>();
-
-  useEffect(() => {
-    const fetchTxType = async () => {
-      if (!req) return;
-      const type = await getTxType(req.transaction.toCore());
-      setTxType(type);
-    };
-    fetchTxType();
-  }, [req]);
 
   const onConfirmTransaction = () => {
     analytics.sendEventToPostHog(PostHogAction.SendTransactionSummaryConfirmClick, {
@@ -96,11 +83,7 @@ export const ConfirmTransaction = (): React.ReactElement => {
 
   return (
     <Layout layoutClassname={cn(confirmTransactionError && styles.layoutError)} pageClassname={styles.spaceBetween}>
-      {req && txType ? (
-        <ConfirmTransactionContent txType={txType} onError={() => setConfirmTransactionError(true)} />
-      ) : (
-        <Skeleton loading />
-      )}
+      {req ? <DappTransactionContainer /> : <Skeleton loading />}
       {!confirmTransactionError && (
         <div className={styles.actions}>
           <Button
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/DappTransactionContainer.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/DappTransactionContainer.tsx
index a394a0ce1..570812c7b 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/DappTransactionContainer.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/DappTransactionContainer.tsx
@@ -1,6 +1,11 @@
 import React, { useState, useEffect, useMemo } from 'react';
 import { useObservable } from '@lace/common';
-import { DappTransaction } from '@lace/core';
+import {
+  DappTransaction,
+  TxDetailsCertificates,
+  TxDetailsProposalProcedures,
+  TxDetailsVotingProcedures
+} from '@lace/core';
 import { Flex } from '@input-output-hk/lace-ui-toolkit';
 import { useViewsFlowContext } from '@providers/ViewFlowProvider';
 
@@ -26,6 +31,8 @@ import { utxoAndBackendChainHistoryResolver } from '@src/utils/utxo-chain-histor
 import { eraSlotDateTime } from '@src/utils/era-slot-datetime';
 import { AddressBookSchema, useDbStateValue } from '@lib/storage';
 import { getAllWalletsAddresses } from '@src/utils/get-all-wallets-addresses';
+import { useCexplorerBaseUrl, useDisallowSignTx } from './hooks';
+import { NonRegisteredUserModal } from './NonRegisteredUserModal/NonRegisteredUserModal';
 
 interface DappTransactionContainerProps {
   errorMessage?: string;
@@ -43,8 +50,13 @@ export const DappTransactionContainer = withAddressBookContext(
       inMemoryWallet,
       blockchainProvider: { assetProvider },
       walletUI: { cardanoCoin },
-      walletState
+      walletState,
+      currentChain
     } = useWalletStore();
+    const [isNonRegisteredUserModalVisible, setIsNonRegisteredUserModalVisible] = useState<boolean>(false);
+    const [userAckNonRegisteredState, setUserAckNonRegisteredState] = useState<boolean>(false);
+    const disallowSignTx = useDisallowSignTx(req);
+    const explorerBaseUrl = useCexplorerBaseUrl();
 
     const ownAddresses = useObservable(inMemoryWallet.addresses$)?.map((a) => a.address);
     const { list: addressBook } = useAddressBookContext() as useDbStateValue<AddressBookSchema>;
@@ -78,6 +90,18 @@ export const DappTransactionContainer = withAddressBookContext(
     );
 
     const tx = useMemo(() => req?.transaction.toCore(), [req?.transaction]);
+
+    useEffect(() => {
+      if (userAckNonRegisteredState || !tx?.body?.votingProcedures) return () => void 0;
+      const subscription = inMemoryWallet?.governance?.isRegisteredAsDRep$?.subscribe(
+        (hasValidDrepRegistration): void => {
+          setIsNonRegisteredUserModalVisible(!hasValidDrepRegistration);
+        }
+      );
+
+      return () => subscription?.unsubscribe();
+    }, [inMemoryWallet?.governance?.isRegisteredAsDRep$, userAckNonRegisteredState, tx]);
+
     const txCollateral = useComputeTxCollateral(walletState, tx);
 
     const userAddresses = useMemo(() => walletInfo.addresses.map((v) => v.address), [walletInfo.addresses]);
@@ -144,21 +168,51 @@ export const DappTransactionContainer = withAddressBookContext(
 
     return (
       <Flex flexDirection="column" justifyContent="space-between" alignItems="stretch">
+        <NonRegisteredUserModal
+          visible={isNonRegisteredUserModalVisible}
+          onConfirm={() => {
+            setUserAckNonRegisteredState(true);
+            setIsNonRegisteredUserModalVisible(false);
+          }}
+          onClose={() => disallowSignTx(true)}
+        />
         {req && transactionInspectionDetails && dappInfo ? (
-          <DappTransaction
-            fiatCurrencyCode={fiatCurrency?.code}
-            fiatCurrencyPrice={priceResult?.cardano?.price}
-            coinSymbol={cardanoCoin.symbol}
-            txInspectionDetails={transactionInspectionDetails}
-            dappInfo={dappInfo}
-            fromAddress={fromAddressTokens}
-            errorMessage={errorMessage}
-            toAddress={toAddressTokens}
-            collateral={txCollateral}
-            expiresBy={eraSlotDateTime(eraSummaries, tx.body.validityInterval?.invalidHereafter)}
-            ownAddresses={allWalletsAddresses.length > 0 ? allWalletsAddresses : ownAddresses}
-            addressToNameMap={addressToNameMap}
-          />
+          <>
+            <DappTransaction
+              fiatCurrencyCode={fiatCurrency?.code}
+              fiatCurrencyPrice={priceResult?.cardano?.price}
+              coinSymbol={cardanoCoin.symbol}
+              txInspectionDetails={transactionInspectionDetails}
+              dappInfo={dappInfo}
+              fromAddress={fromAddressTokens}
+              errorMessage={errorMessage}
+              toAddress={toAddressTokens}
+              collateral={txCollateral}
+              expiresBy={eraSlotDateTime(eraSummaries, tx.body.validityInterval?.invalidHereafter)}
+              ownAddresses={allWalletsAddresses.length > 0 ? allWalletsAddresses : ownAddresses}
+              addressToNameMap={addressToNameMap}
+            />
+            {tx?.body?.certificates?.length > 0 && (
+              <TxDetailsCertificates
+                cardanoCoin={cardanoCoin}
+                certificates={tx.body.certificates}
+                chainNetworkId={currentChain.networkId}
+              />
+            )}
+            {tx?.body?.proposalProcedures?.length > 0 && (
+              <TxDetailsProposalProcedures
+                explorerBaseUrl={explorerBaseUrl}
+                cardanoCoin={cardanoCoin}
+                proposalProcedures={tx.body.proposalProcedures}
+              />
+            )}
+            {tx?.body?.votingProcedures?.length > 0 && (
+              <TxDetailsVotingProcedures
+                explorerBaseUrl={explorerBaseUrl}
+                votingProcedures={tx.body.votingProcedures}
+              />
+            )}
+          </>
         ) : (
           <Skeleton loading />
         )}
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/ConfirmTransaction.test.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/ConfirmTransaction.test.tsx
index c2847651c..34c2680e8 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/ConfirmTransaction.test.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/ConfirmTransaction.test.tsx
@@ -2,15 +2,16 @@
 /* eslint-disable sonarjs/no-identical-functions */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable import/imports-first */
+/* eslint-disable no-magic-numbers */
 const mockGetKeyAgentType = jest.fn();
 const mockUseWalletStore = jest.fn();
 const mockExposeApi = jest.fn(() => ({ shutdown: jest.fn() }));
 const mockConfirmTransactionContent = jest.fn(() => <span data-testid="ConfirmTransactionContent" />);
-const mockGetTxType = jest.fn();
 const mockUseDisallowSignTx = jest.fn();
 const mockUseViewsFlowContext = jest.fn();
 const mockUseSignWithHardwareWallet = jest.fn();
 const mockUseOnBeforeUnload = jest.fn();
+const mockUseComputeTxCollateral = jest.fn().mockReturnValue(BigInt(1_000_000));
 const mockCreateTxInspector = jest.fn().mockReturnValue(() => ({ minted: [] as any, burned: [] as any }));
 import * as React from 'react';
 import { cleanup, render, act, fireEvent } from '@testing-library/react';
@@ -19,6 +20,7 @@ import '@testing-library/jest-dom';
 import { BehaviorSubject } from 'rxjs';
 import { Wallet } from '@lace/cardano';
 import { getWrapper } from '../testing.utils';
+import * as UseComputeTxCollateral from '@hooks/useComputeTxCollateral';
 
 const assetInfo$ = new BehaviorSubject(new Map());
 const available$ = new BehaviorSubject([]);
@@ -33,7 +35,11 @@ const inMemoryWallet = {
     utxo: {
       available$
     }
-  }
+  },
+  delegation: {
+    rewardAccounts$: new BehaviorSubject([])
+  },
+  addresses$: new BehaviorSubject([])
 };
 
 jest.mock('@src/stores', () => ({
@@ -73,21 +79,11 @@ jest.mock('@lace/common', () => {
   };
 });
 
-jest.mock('../ConfirmTransactionContent', () => {
-  const original = jest.requireActual('../ConfirmTransactionContent');
-  return {
-    __esModule: true,
-    ...original,
-    ConfirmTransactionContent: mockConfirmTransactionContent
-  };
-});
-
 jest.mock('../utils.ts', () => {
   const original = jest.requireActual('../utils.ts');
   return {
     __esModule: true,
-    ...original,
-    getTxType: mockGetTxType
+    ...original
   };
 });
 
@@ -102,6 +98,11 @@ jest.mock('../hooks.ts', () => {
   };
 });
 
+jest.mock('@hooks/useComputeTxCollateral', (): typeof UseComputeTxCollateral => ({
+  ...jest.requireActual<typeof UseComputeTxCollateral>('@hooks/useComputeTxCollateral'),
+  useComputeTxCollateral: mockUseComputeTxCollateral
+}));
+
 jest.mock('@providers/ViewFlowProvider', () => {
   const original = jest.requireActual('@providers/ViewFlowProvider');
   return {
@@ -146,7 +147,6 @@ describe('Testing ConfirmTransaction component', () => {
   test('Should render proper state for inMemory wallet', async () => {
     let queryByTestId: any;
 
-    const txType = 'txType';
     mockGetKeyAgentType.mockReset();
     mockGetKeyAgentType.mockReturnValue(Wallet.KeyManagement.KeyAgentType.InMemory);
     mockUseWalletStore.mockReset();
@@ -154,11 +154,11 @@ describe('Testing ConfirmTransaction component', () => {
       getKeyAgentType: mockGetKeyAgentType,
       inMemoryWallet,
       walletUI: {},
-      walletInfo: {},
+      walletInfo: {
+        addresses: []
+      },
       blockchainProvider: { assetProvider }
     }));
-    mockGetTxType.mockReset();
-    mockGetTxType.mockReturnValue(txType);
 
     const signTxData = { tx: { id: 'test-tx-id' } };
     const disallowSignTx = jest.fn();
@@ -184,14 +184,6 @@ describe('Testing ConfirmTransaction component', () => {
       }));
     });
 
-    expect(queryByTestId('ConfirmTransactionContent')).toBeInTheDocument();
-    expect(mockConfirmTransactionContent).toHaveBeenLastCalledWith(
-      {
-        txType,
-        onError: expect.any(Function)
-      },
-      {}
-    );
     expect(mockUseOnBeforeUnload).toHaveBeenCalledWith(disallowSignTx);
     expect(queryByTestId(testIds.dappTransactionConfirm)).toHaveTextContent('Confirm');
     expect(queryByTestId(testIds.dappTransactionConfirm)).not.toBeDisabled();
@@ -222,7 +214,9 @@ describe('Testing ConfirmTransaction component', () => {
       isHardwareWallet: true,
       walletType: 'Ledger',
       walletUI: {},
-      walletInfo: {},
+      walletInfo: {
+        addresses: []
+      },
       blockchainProvider: { assetProvider }
     }));
 
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/DappTransactionContainer.test.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/DappTransactionContainer.test.tsx
index 029399959..4c6fe8e6d 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/DappTransactionContainer.test.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/DappTransactionContainer.test.tsx
@@ -85,8 +85,22 @@ const inMemoryWallet = {
   delegation: {
     rewardAccounts$
   },
-  protocolParameters$
+  protocolParameters$,
+  governance: {
+    isRegisteredAsDRep$: new BehaviorSubject(true)
+  }
+};
+const REWARD_ACCOUNT = Cardano.RewardAccount('stake_test1uqrw9tjymlm8wrwq7jk68n6v7fs9qz8z0tkdkve26dylmfc2ux2hj');
+const STAKE_KEY_HASH = Cardano.RewardAccount.toHash(REWARD_ACCOUNT);
+const STAKE_CREDENTIAL = {
+  type: Cardano.CredentialType.KeyHash,
+  hash: Crypto.Hash28ByteBase16(STAKE_KEY_HASH)
+};
+const DREP_CREDENTIAL = {
+  type: Cardano.CredentialType.KeyHash,
+  hash: Crypto.Hash28ByteBase16(Buffer.from('dRepCredentialHashdRepCreden').toString('hex'))
 };
+const POOL_ID = Cardano.PoolId('pool126zlx7728y7xs08s8epg9qp393kyafy9rzr89g4qkvv4cv93zem');
 
 jest.mock('@src/stores', () => ({
   ...jest.requireActual<any>('@src/stores'),
@@ -159,27 +173,67 @@ const dappInfo = {
   url: 'dappUrl'
 };
 
-const certificate: Wallet.Cardano.Certificate = {
+const mockCredentialKeyHash = Crypto.Hash28ByteBase16(Buffer.from('dRepCredentialHashdRepCreden').toString('hex'));
+
+const drepRegistrationcertificate: Wallet.Cardano.Certificate = {
   __typename: Cardano.CertificateType.RegisterDelegateRepresentative,
-  dRepCredential: {
-    type: Cardano.CredentialType.KeyHash,
-    hash: Crypto.Hash28ByteBase16(Buffer.from('dRepCredentialHashdRepCreden').toString('hex'))
-  },
+  dRepCredential: DREP_CREDENTIAL,
   deposit: BigInt('1000'),
   anchor: {
     url: 'anchorUrl',
     dataHash: Crypto.Hash32ByteBase16(Buffer.from('anchorDataHashanchorDataHashanch').toString('hex'))
   }
 };
-const tx = buildMockTx({
-  certificates: [certificate]
-});
 
-const request = {
-  transaction: {
-    toCore: jest.fn().mockReturnValue(tx)
-  } as any
-} as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+const drepRetirementCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.UnregisterDelegateRepresentative,
+  dRepCredential: DREP_CREDENTIAL,
+  deposit: BigInt('1000')
+};
+
+const drepUpdateCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.UpdateDelegateRepresentative,
+  dRepCredential: DREP_CREDENTIAL,
+  anchor: {
+    url: 'anchorUrl',
+    dataHash: Crypto.Hash32ByteBase16(Buffer.from('anchorDataHashanchorDataHashanch').toString('hex'))
+  }
+};
+
+const stakeRegistrationDelegationCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.StakeRegistrationDelegation,
+  poolId: POOL_ID,
+  stakeCredential: STAKE_CREDENTIAL,
+  deposit: BigInt('100000')
+};
+
+const stakeVoteDelegationCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.StakeVoteDelegation,
+  poolId: POOL_ID,
+  stakeCredential: STAKE_CREDENTIAL,
+  dRep: DREP_CREDENTIAL
+};
+
+const stakeVoteRegistrationDelegationCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.StakeVoteRegistrationDelegation,
+  poolId: POOL_ID,
+  stakeCredential: STAKE_CREDENTIAL,
+  dRep: DREP_CREDENTIAL,
+  deposit: BigInt('100000')
+};
+
+const voteDelegationCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.VoteDelegation,
+  dRep: DREP_CREDENTIAL,
+  stakeCredential: STAKE_CREDENTIAL
+};
+
+const voteRegistrationDelegationCertificate: Wallet.Cardano.Certificate = {
+  __typename: Cardano.CertificateType.VoteRegistrationDelegation,
+  stakeCredential: STAKE_CREDENTIAL,
+  dRep: DREP_CREDENTIAL,
+  deposit: BigInt('100000')
+};
 
 jest.mock('@providers/ViewFlowProvider', () => ({
   ...jest.requireActual<any>('@providers/ViewFlowProvider'),
@@ -193,7 +247,11 @@ describe('Testing DappTransactionContainer component', () => {
       inMemoryWallet,
       blockchainProvider: { assetProvider },
       walletInfo,
-      walletUI: { cardanoCoin }
+      walletUI: { cardanoCoin },
+      currentChain: {
+        networkId: 0,
+        networkMagic: 1
+      }
     }));
     mockDappTransaction.mockReset();
     mockDappTransaction.mockReturnValue(<span data-testid="DappTransaction" />);
@@ -204,10 +262,6 @@ describe('Testing DappTransactionContainer component', () => {
     mockSkeleton.mockReset();
     mockSkeleton.mockImplementation(() => <span data-testid="skeleton" />);
     mockUseViewsFlowContext.mockReset();
-    mockUseViewsFlowContext.mockImplementation(() => ({
-      signTxRequest: { request, set: jest.fn() },
-      dappInfo
-    }));
   });
 
   afterEach(() => {
@@ -219,8 +273,16 @@ describe('Testing DappTransactionContainer component', () => {
   test('should render DappTransaction component with proper props', async () => {
     let queryByTestId: any;
 
-    const errorMessage = 'errorMessage';
-    const props = { errorMessage };
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(buildMockTx({ certificates: [drepRegistrationcertificate] }))
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
 
     const toAddress = new Map([
       [
@@ -319,7 +381,7 @@ describe('Testing DappTransactionContainer component', () => {
     };
 
     await act(async () => {
-      ({ queryByTestId } = render(<DappTransactionContainer {...props} />, {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
         wrapper: getWrapper()
       }));
     });
@@ -332,7 +394,6 @@ describe('Testing DappTransactionContainer component', () => {
         fromAddress: new Map(),
         fiatCurrencyCode: 'usd',
         fiatCurrencyPrice: 2,
-        errorMessage,
         coinSymbol: 'ADA',
         collateral: BigInt(1_000_000),
         txInspectionDetails,
@@ -343,6 +404,290 @@ describe('Testing DappTransactionContainer component', () => {
     );
   });
 
+  it('should display drep registration certificate', async () => {
+    let queryByTestId: any;
+    const drepRegistrationTx = buildMockTx({ certificates: [drepRegistrationcertificate] });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(drepRegistrationTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display drep retirement certificate', async () => {
+    let queryByTestId: any;
+    const drepRetirementCertificateTx = buildMockTx({ certificates: [drepRetirementCertificate] });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(drepRetirementCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display drep update certificate', async () => {
+    let queryByTestId: any;
+    const drepUpdateCertificateTx = buildMockTx({ certificates: [drepUpdateCertificate] });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(drepUpdateCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display stake registration delegation certificate', async () => {
+    let queryByTestId: any;
+    const stakeRegistrationDelegationCertificateTx = buildMockTx({
+      certificates: [stakeRegistrationDelegationCertificate]
+    });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(stakeRegistrationDelegationCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display stake vote delegation certificate', async () => {
+    let queryByTestId: any;
+    const stakeVoteDelegationCertificateTx = buildMockTx({ certificates: [stakeVoteDelegationCertificate] });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(stakeVoteDelegationCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display stake vote registration delegation certificate', async () => {
+    let queryByTestId: any;
+    const stakeVoteRegistrationDelegationCertificateTx = buildMockTx({
+      certificates: [stakeVoteRegistrationDelegationCertificate]
+    });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(stakeVoteRegistrationDelegationCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display vote delegation certificate', async () => {
+    let queryByTestId: any;
+    const voteDelegationCertificateTx = buildMockTx({ certificates: [voteDelegationCertificate] });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(voteDelegationCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display vote registration delegation certificate', async () => {
+    let queryByTestId: any;
+    const voteRegistrationDelegationCertificateTx = buildMockTx({
+      certificates: [voteRegistrationDelegationCertificate]
+    });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(voteRegistrationDelegationCertificateTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('certificates')).toBeInTheDocument();
+  });
+
+  it('should display votes', async () => {
+    let queryByTestId: any;
+    const votingTx = buildMockTx({
+      votingProcedures: [
+        {
+          voter: {
+            __typename: Cardano.VoterType.dRepKeyHash,
+            credential: {
+              type: Cardano.CredentialType.KeyHash,
+              hash: mockCredentialKeyHash
+            }
+          },
+          votes: [
+            {
+              actionId: {
+                id: Cardano.TransactionId('724a0a88b9470a714fc5bf84daf5851fa259a9b89e1a5453f6f5cd6595ad9821'),
+                actionIndex: 0
+              },
+              votingProcedure: {
+                vote: Cardano.Vote.yes,
+                anchor: {
+                  url: 'anchorUrl',
+                  dataHash: Crypto.Hash32ByteBase16(Buffer.from('anchorDataHashanchorDataHashanc1').toString('hex'))
+                }
+              }
+            }
+          ]
+        }
+      ]
+    });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(votingTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockReset();
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: {
+        request
+      },
+      dappInfo
+    }));
+
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('voting-procedures')).toBeInTheDocument();
+  });
+
+  it('should render proposal procedures', async () => {
+    let queryByTestId: any;
+    const proposalProceduresTx = buildMockTx({
+      proposalProcedures: [
+        {
+          anchor: {
+            url: 'anchorUrl',
+            dataHash: Crypto.Hash32ByteBase16(Buffer.from('anchorDataHashanchorDataHashanc1').toString('hex'))
+          },
+          governanceAction: {
+            __typename: Cardano.GovernanceActionType.info_action
+          },
+          deposit: BigInt('100000'),
+          rewardAccount: REWARD_ACCOUNT
+        }
+      ]
+    });
+    const request = {
+      transaction: {
+        toCore: jest.fn().mockReturnValue(proposalProceduresTx)
+      } as any
+    } as TransactionWitnessRequest<Wallet.WalletMetadata, Wallet.AccountMetadata>;
+
+    mockUseViewsFlowContext.mockImplementation(() => ({
+      signTxRequest: { request, set: jest.fn() },
+      dappInfo
+    }));
+    await act(async () => {
+      ({ queryByTestId } = render(<DappTransactionContainer />, {
+        wrapper: getWrapper()
+      }));
+    });
+
+    expect(queryByTestId('DappTransaction')).toBeInTheDocument();
+    expect(queryByTestId('proposal-procedures')).toBeInTheDocument();
+  });
+
   test('should render loader in case there is no tx data', async () => {
     let queryByTestId: any;
 
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/utils.test.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/utils.test.tsx
index 2e3bc31cd..c01689d94 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/utils.test.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/__tests__/utils.test.tsx
@@ -9,11 +9,9 @@ mockHexBlob.toTypedBech32 = (prefix: string, value: string) => `${prefix}${value
 import { cleanup } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import { Wallet } from '@lace/cardano';
-import * as Core from '@cardano-sdk/core';
 import {
   certificateInspectorFactory,
   votingProceduresInspector,
-  getTxType,
   pubDRepKeyToHash,
   depositPaidWithSymbol
 } from '../utils';
@@ -78,73 +76,6 @@ describe('Testing utils', () => {
     expect(await votingProceduresInspector({ body: {} } as Wallet.Cardano.Tx)).toEqual(undefined);
   });
 
-  test('testing getTxType', async () => {
-    const tx = { body: {} } as Wallet.Cardano.Tx;
-    const txInspectorCurriedFnPayload = { minted: [], burned: [] } as unknown as any;
-    const createTxInspectorSpy = jest
-      .spyOn(Core, 'createTxInspector')
-      .mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, proposalProcedures: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.ProposalProcedures);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(1);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, votingProcedures: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.VotingProcedures);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(2);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, minted: { length: 1 } }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.Mint);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(3);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, burned: { length: 1 } }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.Burn);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(4);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, dRepRegistration: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.DRepRegistration);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(5);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, dRepRetirement: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.DRepRetirement);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(6);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, voteDelegation: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.VoteDelegation);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(7);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, dRepUpdate: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.DRepUpdate);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(8);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload, stakeVoteDelegation: true }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.StakeVoteDelegation);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(9);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({
-      ...txInspectorCurriedFnPayload,
-      voteRegistrationDelegation: true
-    }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.VoteRegistrationDelegation);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(10);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({
-      ...txInspectorCurriedFnPayload,
-      stakeRegistrationDelegation: true
-    }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.StakeRegistrationDelegation);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(11);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({
-      ...txInspectorCurriedFnPayload,
-      stakeVoteDelegationRegistration: true
-    }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.StakeVoteDelegationRegistration);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(12);
-
-    createTxInspectorSpy.mockReturnValueOnce(() => ({ ...txInspectorCurriedFnPayload }));
-    expect(await getTxType(tx)).toEqual(Wallet.Cip30TxType.Send);
-    expect(createTxInspectorSpy).toHaveBeenCalledTimes(13);
-  });
-
   test('testing drepIDasBech32FromHash', () => {
     expect(
       Wallet.util.drepIDasBech32FromHash(
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/testing.utils.tsx b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/testing.utils.tsx
index c7d258dbb..394311418 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/testing.utils.tsx
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/testing.utils.tsx
@@ -6,6 +6,7 @@ import {
   AppSettingsProvider,
   BackgroundServiceAPIProvider,
   BackgroundServiceAPIProviderProps,
+  CurrencyStoreProvider,
   DatabaseProvider,
   ViewFlowProvider
 } from '@src/providers';
@@ -15,10 +16,14 @@ import { PostHogClientProvider } from '@providers/PostHogClientProvider';
 import { postHogClientMocks } from '@src/utils/mocks/test-helpers';
 import React from 'react';
 import { sendViewsFlowState } from '../../config';
+import { BehaviorSubject } from 'rxjs';
 
+const tokenPrices$ = new BehaviorSubject({});
+const adaPrices$ = new BehaviorSubject({});
 const backgroundService = {
   getBackgroundStorage: jest.fn(),
-  setBackgroundStorage: jest.fn()
+  setBackgroundStorage: jest.fn(),
+  coinPrices: { tokenPrices$, adaPrices$ }
 } as unknown as BackgroundServiceAPIProviderProps['value'];
 
 export const getWrapper =
@@ -27,17 +32,19 @@ export const getWrapper =
     (
       <BackgroundServiceAPIProvider value={backgroundService}>
         <AppSettingsProvider>
-          <DatabaseProvider>
-            <StoreProvider appMode={APP_MODE_BROWSER}>
-              <PostHogClientProvider postHogCustomClient={postHogClientMocks as any}>
-                <AnalyticsProvider analyticsDisabled>
-                  <I18nextProvider i18n={i18n}>
-                    <ViewFlowProvider viewStates={sendViewsFlowState}>{children}</ViewFlowProvider>
-                  </I18nextProvider>
-                </AnalyticsProvider>
-              </PostHogClientProvider>
-            </StoreProvider>
-          </DatabaseProvider>
+          <CurrencyStoreProvider>
+            <DatabaseProvider>
+              <StoreProvider appMode={APP_MODE_BROWSER}>
+                <PostHogClientProvider postHogCustomClient={postHogClientMocks as any}>
+                  <AnalyticsProvider analyticsDisabled>
+                    <I18nextProvider i18n={i18n}>
+                      <ViewFlowProvider viewStates={sendViewsFlowState}>{children}</ViewFlowProvider>
+                    </I18nextProvider>
+                  </AnalyticsProvider>
+                </PostHogClientProvider>
+              </StoreProvider>
+            </DatabaseProvider>
+          </CurrencyStoreProvider>
         </AppSettingsProvider>
       </BackgroundServiceAPIProvider>
     );
diff --git a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/utils.ts b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/utils.ts
index 25f77a897..ae15bd6d4 100644
--- a/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/utils.ts
+++ b/apps/browser-extension-wallet/src/features/dapp/components/confirm-transaction/utils.ts
@@ -1,7 +1,6 @@
 /* eslint-disable sonarjs/no-small-switch */
 /* eslint-disable complexity */
 import { Wallet } from '@lace/cardano';
-import { assetsBurnedInspector, assetsMintedInspector, createTxInspector } from '@cardano-sdk/core';
 import { RemoteApiPropertyType, TransactionWitnessRequest, WalletType, exposeApi } from '@cardano-sdk/web-extension';
 import type { UserPromptService } from '@lib/scripts/background/services';
 import { DAPP_CHANNELS, cardanoCoin } from '@src/utils/constants';
@@ -60,90 +59,6 @@ export const proposalProceduresInspector = async (
   tx: Wallet.Cardano.Tx
 ): Promise<Wallet.Cardano.ProposalProcedure[] | undefined> => tx?.body?.proposalProcedures;
 
-export const getTxType = async (tx: Wallet.Cardano.Tx): Promise<Wallet.Cip30TxType> => {
-  const inspector = createTxInspector({
-    minted: assetsMintedInspector,
-    burned: assetsBurnedInspector,
-    votingProcedures: votingProceduresInspector,
-    proposalProcedures: proposalProceduresInspector,
-    dRepRegistration: certificateInspectorFactory(CertificateType.RegisterDelegateRepresentative),
-    dRepRetirement: certificateInspectorFactory(CertificateType.UnregisterDelegateRepresentative),
-    dRepUpdate: certificateInspectorFactory(CertificateType.UpdateDelegateRepresentative),
-    voteDelegation: certificateInspectorFactory(CertificateType.VoteDelegation),
-    voteRegistrationDelegation: certificateInspectorFactory(CertificateType.VoteRegistrationDelegation),
-    stakeVoteDelegation: certificateInspectorFactory(CertificateType.StakeVoteDelegation),
-    stakeRegistrationDelegation: certificateInspectorFactory(CertificateType.StakeRegistrationDelegation),
-    stakeVoteDelegationRegistration: certificateInspectorFactory(CertificateType.StakeVoteRegistrationDelegation)
-  });
-
-  const {
-    minted,
-    burned,
-    votingProcedures,
-    dRepRegistration,
-    dRepRetirement,
-    dRepUpdate,
-    voteDelegation,
-    stakeVoteDelegation,
-    voteRegistrationDelegation,
-    stakeRegistrationDelegation,
-    stakeVoteDelegationRegistration,
-    proposalProcedures
-  } = await inspector(tx as Wallet.Cardano.HydratedTx);
-  const isMintTransaction = minted.length > 0;
-  const isBurnTransaction = burned.length > 0;
-
-  if (proposalProcedures) {
-    return Wallet.Cip30TxType.ProposalProcedures;
-  }
-
-  if (votingProcedures) {
-    return Wallet.Cip30TxType.VotingProcedures;
-  }
-
-  if (isMintTransaction) {
-    return Wallet.Cip30TxType.Mint;
-  }
-
-  if (isBurnTransaction) {
-    return Wallet.Cip30TxType.Burn;
-  }
-
-  if (dRepRegistration) {
-    return Wallet.Cip30TxType.DRepRegistration;
-  }
-
-  if (dRepRetirement) {
-    return Wallet.Cip30TxType.DRepRetirement;
-  }
-
-  if (voteDelegation) {
-    return Wallet.Cip30TxType.VoteDelegation;
-  }
-
-  if (stakeVoteDelegation) {
-    return Wallet.Cip30TxType.StakeVoteDelegation;
-  }
-
-  if (voteRegistrationDelegation) {
-    return Wallet.Cip30TxType.VoteRegistrationDelegation;
-  }
-
-  if (stakeRegistrationDelegation) {
-    return Wallet.Cip30TxType.StakeRegistrationDelegation;
-  }
-
-  if (stakeVoteDelegationRegistration) {
-    return Wallet.Cip30TxType.StakeVoteDelegationRegistration;
-  }
-
-  if (dRepUpdate) {
-    return Wallet.Cip30TxType.DRepUpdate;
-  }
-
-  return Wallet.Cip30TxType.Send;
-};
-
 export const pubDRepKeyToHash = async (
   pubDRepKeyHex: Wallet.Crypto.Ed25519PublicKeyHex
 ): Promise<Wallet.Crypto.Hash28ByteBase16> => {
diff --git a/apps/browser-extension-wallet/src/utils/mocks/tx.ts b/apps/browser-extension-wallet/src/utils/mocks/tx.ts
index a41522f82..2f97b7bc1 100644
--- a/apps/browser-extension-wallet/src/utils/mocks/tx.ts
+++ b/apps/browser-extension-wallet/src/utils/mocks/tx.ts
@@ -17,6 +17,8 @@ export const buildMockTx = (
     outputs?: Wallet.Cardano.TxOut[];
     certificates?: Wallet.Cardano.Certificate[];
     withdrawals?: Wallet.Cardano.Withdrawal[];
+    votingProcedures?: Wallet.Cardano.VotingProcedures;
+    proposalProcedures?: Wallet.Cardano.ProposalProcedure[];
   } = {}
 ): Wallet.Cardano.HydratedTx =>
   ({
@@ -34,6 +36,8 @@ export const buildMockTx = (
       mint: new Map([
         [Wallet.Cardano.AssetId('659f2917fb63f12b33667463ee575eeac1845bbc736b9c0bbc40ba8254534c41'), BigInt(3)]
       ]),
+      proposalProcedures: args.proposalProcedures || undefined,
+      votingProcedures: args.votingProcedures || undefined,
       inputs: args.inputs ?? [
         {
           address: sendingAddress.address,