diff --git a/packages/blockchain-link-types/src/responses.ts b/packages/blockchain-link-types/src/responses.ts
index a28c3afdba3..6e26e189edd 100644
--- a/packages/blockchain-link-types/src/responses.ts
+++ b/packages/blockchain-link-types/src/responses.ts
@@ -98,6 +98,7 @@ export interface EstimateFee {
     payload: {
         feePerUnit: string;
         feePerTx?: string;
+        feePayer?: string;
         feeLimit?: string;
         eip1559?: Eip1559Fees;
     }[];
diff --git a/packages/blockchain-link/src/workers/solana/fee.ts b/packages/blockchain-link/src/workers/solana/fee.ts
index 9727f95d65c..3cdc8cd28f8 100644
--- a/packages/blockchain-link/src/workers/solana/fee.ts
+++ b/packages/blockchain-link/src/workers/solana/fee.ts
@@ -1,6 +1,7 @@
 import {
     Address,
     Base64EncodedWireTransaction,
+    CompilableTransactionMessage,
     CompiledTransactionMessage,
     GetFeeForMessageApi,
     GetRecentPrioritizationFeesApi,
@@ -9,7 +10,6 @@ import {
     SimulateTransactionApi,
     TransactionMessageBytes,
     TransactionMessageBytesBase64,
-    decompileTransactionMessage,
     getBase64Decoder,
     getCompiledTransactionMessageEncoder,
     getTransactionEncoder,
@@ -56,12 +56,12 @@ export const getBaseFee = async (
 // https://solana.com/developers/guides/advanced/how-to-use-priority-fees#how-do-i-estimate-priority-fees
 export const getPriorityFee = async (
     api: Rpc<GetRecentPrioritizationFeesApi & SimulateTransactionApi>,
+    decompiledMessage: CompilableTransactionMessage,
     compiledMessage: CompiledTransactionMessage,
     signatures: SignaturesMap,
 ) => {
-    const message = decompileTransactionMessage(compiledMessage);
     const affectedAccounts = new Set<Address>(
-        message.instructions
+        decompiledMessage.instructions
             .flatMap(instruction => instruction.accounts ?? [])
             .filter(({ role }) => isWritableRole(role))
             .map(({ address }) => address),
diff --git a/packages/blockchain-link/src/workers/solana/index.ts b/packages/blockchain-link/src/workers/solana/index.ts
index f16d1d38ae9..ddd68aef26d 100644
--- a/packages/blockchain-link/src/workers/solana/index.ts
+++ b/packages/blockchain-link/src/workers/solana/index.ts
@@ -22,6 +22,7 @@ import {
     createSolanaRpcFromTransport,
     createSolanaRpcSubscriptions,
     decompileTransactionMessage,
+    decompileTransactionMessageFetchingLookupTables,
     getBase16Encoder,
     getBase64Encoder,
     getCompiledTransactionMessageDecoder,
@@ -482,7 +483,17 @@ const estimateFee = async (request: Request<MessageTypes.EstimateFee>) => {
     const transaction = pipe(messageHex, getBase16Encoder().encode, getTransactionDecoder().decode);
     const message = pipe(transaction.messageBytes, getCompiledTransactionMessageDecoder().decode);
 
-    const priorityFee = await getPriorityFee(api.rpc, message, transaction.signatures);
+    const decompiledTransactionMessage = await decompileTransactionMessageFetchingLookupTables(
+        message,
+        api.rpc,
+    );
+
+    const priorityFee = await getPriorityFee(
+        api.rpc,
+        decompiledTransactionMessage,
+        message,
+        transaction.signatures,
+    );
     const baseFee = await getBaseFee(api.rpc, message);
 
     const accountCreationFee = newAccountProgramName
@@ -501,6 +512,7 @@ const estimateFee = async (request: Request<MessageTypes.EstimateFee>) => {
                 .toString(10),
             feePerUnit: priorityFee.computeUnitPrice,
             feeLimit: priorityFee.computeUnitLimit,
+            feePayer: decompiledTransactionMessage.feePayer.address,
         },
     ];
 
diff --git a/packages/components/src/components/form/Select/Select.tsx b/packages/components/src/components/form/Select/Select.tsx
index 401c607cd5a..80410eb15ef 100644
--- a/packages/components/src/components/form/Select/Select.tsx
+++ b/packages/components/src/components/form/Select/Select.tsx
@@ -116,6 +116,7 @@ type WrapperProps = TransientProps<
     $isWithPlaceholder: boolean;
     $elevation: Elevation;
     $isLoading?: boolean;
+    $menuFitContent?: boolean;
 };
 
 const SelectWrapper = styled.div<WrapperProps>`
@@ -230,6 +231,11 @@ const SelectWrapper = styled.div<WrapperProps>`
         ${menuStyle}
         border: none;
         z-index: ${zIndices.base};
+        ${({ $menuFitContent }) =>
+            $menuFitContent &&
+            css`
+                width: fit-content;
+            `}
     }
 
     ${({ $isDisabled }) =>
@@ -276,6 +282,7 @@ export type SelectProps = KeyPressScrollProps &
         label?: ReactNode;
         size?: InputSize;
         minValueWidth?: string;
+        menuFitContent?: boolean;
         isMenuOpen?: boolean;
         isLoading?: boolean;
         onChange?: (value: Option, ref?: SelectInstance<Option, boolean> | null) => void;
@@ -289,6 +296,7 @@ export const Select = ({
     useKeyPressScroll,
     isSearchable = false,
     minValueWidth = 'initial',
+    menuFitContent,
     isMenuOpen,
     components,
     onChange,
@@ -348,6 +356,7 @@ export const Select = ({
                 $isSearchable={isSearchable}
                 $size={size}
                 $minValueWidth={minValueWidth}
+                $menuFitContent={menuFitContent}
                 $isDisabled={isDisabled}
                 $isLoading={isLoading}
                 $isMenuOpen={isMenuOpen}
diff --git a/packages/suite/src/components/suite/modals/ReduxModal/UserContextModal/WalletConnectProposalModal.tsx b/packages/suite/src/components/suite/modals/ReduxModal/UserContextModal/WalletConnectProposalModal.tsx
index 2153f13af45..fdfdf81689a 100644
--- a/packages/suite/src/components/suite/modals/ReduxModal/UserContextModal/WalletConnectProposalModal.tsx
+++ b/packages/suite/src/components/suite/modals/ReduxModal/UserContextModal/WalletConnectProposalModal.tsx
@@ -1,34 +1,131 @@
+import { useEffect, useMemo, useState } from 'react';
+import { GroupBase } from 'react-select';
+
+import { TrezorDevice } from '@suite-common/suite-types';
+import { AccountType, NetworkType } from '@suite-common/wallet-config';
+import { selectAccounts, selectDevices } from '@suite-common/wallet-core';
+import { Account } from '@suite-common/wallet-types';
 import {
     selectPendingProposal,
     sessionProposalApproveThunk,
     sessionProposalRejectThunk,
 } from '@suite-common/walletconnect';
-import { Banner, Card, H2, NewModal, Note, Paragraph, Row, Text } from '@trezor/components';
+import { PendingConnectionProposalNetwork } from '@suite-common/walletconnect/src/walletConnectTypes';
+import {
+    Banner,
+    Card,
+    H2,
+    NewModal,
+    Note,
+    Option,
+    Paragraph,
+    Row,
+    Select,
+    Text,
+} from '@trezor/components';
 import { BannerButton } from '@trezor/components/src/components/Banner/BannerButton';
 import { CoinLogo } from '@trezor/product-components';
 import { spacings } from '@trezor/theme';
 
 import { onCancel } from 'src/actions/suite/modalActions';
 import { goto } from 'src/actions/suite/routerActions';
-import { Translation } from 'src/components/suite';
+import { AccountLabel, Translation, WalletLabeling } from 'src/components/suite';
+import { AccountTypeBadge } from 'src/components/suite/AccountTypeBadge';
 import { useDispatch, useSelector } from 'src/hooks/suite';
+import { selectAccountLabels } from 'src/reducers/suite/metadataReducer';
 
 interface WalletConnectProposalModalProps {
     eventId: number;
 }
 
+interface AccountGroup extends GroupBase<Account> {
+    options: Account[];
+    label: string;
+    device: TrezorDevice;
+    accountType: AccountType;
+    networkType: NetworkType;
+}
+
 export const WalletConnectProposalModal = ({ eventId }: WalletConnectProposalModalProps) => {
     const dispatch = useDispatch();
     const pendingProposal = useSelector(selectPendingProposal);
+    const accounts = useSelector(selectAccounts);
+    const accountLabels = useSelector(selectAccountLabels);
+    const devices = useSelector(selectDevices);
+    const [selectedDefaultAccounts, setSelectedDefaultAccounts] = useState<Account[]>([]);
 
     const handleAccept = () => {
-        dispatch(sessionProposalApproveThunk({ eventId }));
+        dispatch(sessionProposalApproveThunk({ eventId, selectedDefaultAccounts }));
         dispatch(onCancel());
     };
     const handleReject = () => {
         dispatch(sessionProposalRejectThunk({ eventId }));
         dispatch(onCancel());
     };
+    const handleSelectAccount = (account: Account) => {
+        setSelectedDefaultAccounts(prev => {
+            const newAccounts = prev.filter(prevAccount => prevAccount.symbol !== account.symbol);
+
+            return [...newAccounts, account];
+        });
+    };
+
+    const orderedAccounts = useMemo(
+        () =>
+            [...accounts]
+                .filter(account => account.visible)
+                .map(account => ({
+                    ...account,
+                    accountLabel: accountLabels[account.key],
+                }))
+                .sort((a, b) => {
+                    if (a.deviceState !== b.deviceState) {
+                        return a.deviceState.localeCompare(b.deviceState);
+                    }
+                    if (a.accountType !== b.accountType) {
+                        // normal first
+                        if (a.accountType === 'normal' && b.accountType !== 'normal') return -1;
+                        if (a.accountType !== 'normal' && b.accountType === 'normal') return 1;
+
+                        return a.accountType.localeCompare(b.accountType);
+                    }
+
+                    return a.index - b.index;
+                }),
+        [accounts, accountLabels],
+    );
+    useEffect(() => {
+        const newDefaultAccounts = pendingProposal?.networks
+            .filter(network => network.status === 'active')
+            .map(network => orderedAccounts.find(account => account.symbol === network.symbol))
+            .filter(Boolean) as Account[];
+        setSelectedDefaultAccounts(newDefaultAccounts);
+    }, [orderedAccounts, pendingProposal?.networks]);
+
+    const buildAccountOptionGroups = (network: PendingConnectionProposalNetwork) => {
+        const groups: AccountGroup[] = [];
+        orderedAccounts
+            .filter(account => account.symbol === network.symbol)
+            .forEach(account => {
+                const device = devices.find(d => d.state?.staticSessionId === account.deviceState);
+                if (!device) return;
+                const label = `${account.deviceState}-${account.accountType}`;
+                const group = groups.find(g => g.label === label);
+                if (group) {
+                    group.options.push(account);
+                } else {
+                    groups.push({
+                        label,
+                        device,
+                        accountType: account.accountType,
+                        networkType: account.networkType,
+                        options: [account],
+                    });
+                }
+            });
+
+        return groups;
+    };
 
     if (!pendingProposal) return null;
 
@@ -103,12 +200,59 @@ export const WalletConnectProposalModal = ({ eventId }: WalletConnectProposalMod
                                                 size={24}
                                             />
                                         )}
-                                        <Text>
-                                            {network.name}
-                                            {network.required && (
-                                                <Text variant="destructive">*</Text>
-                                            )}
-                                        </Text>
+                                        {status === 'active' &&
+                                        network.namespaceId.startsWith('solana') ? (
+                                            <Select
+                                                isSearchable={false}
+                                                isClearable={false}
+                                                isClean
+                                                menuFitContent
+                                                size="small"
+                                                value={selectedDefaultAccounts.find(
+                                                    account => account.symbol === network.symbol,
+                                                )}
+                                                options={buildAccountOptionGroups(network)}
+                                                formatGroupLabel={(data: GroupBase<Account>) => (
+                                                    <Row gap={spacings.xs}>
+                                                        <WalletLabeling
+                                                            device={(data as AccountGroup).device}
+                                                            shouldUseDeviceLabel
+                                                        />
+                                                        <AccountTypeBadge
+                                                            accountType={
+                                                                (data as AccountGroup).accountType
+                                                            }
+                                                            networkType={
+                                                                (data as AccountGroup).networkType
+                                                            }
+                                                            size="small"
+                                                            onElevation
+                                                        />
+                                                    </Row>
+                                                )}
+                                                formatOptionLabel={(account: Account) => (
+                                                    <AccountLabel
+                                                        key={account.descriptor}
+                                                        accountLabel={account.accountLabel}
+                                                        accountType={account.accountType}
+                                                        networkType={account.networkType}
+                                                        symbol={account.symbol}
+                                                        index={account.index}
+                                                        path={account.path}
+                                                    />
+                                                )}
+                                                onChange={(option: Option) =>
+                                                    handleSelectAccount(option)
+                                                }
+                                            />
+                                        ) : (
+                                            <Text>
+                                                {network.name}
+                                                {network.required && (
+                                                    <Text variant="destructive">*</Text>
+                                                )}
+                                            </Text>
+                                        )}
                                     </Row>
                                 ))}
                             </Row>
diff --git a/suite-common/walletconnect/package.json b/suite-common/walletconnect/package.json
index 2a8772b7e5b..200943e68a5 100644
--- a/suite-common/walletconnect/package.json
+++ b/suite-common/walletconnect/package.json
@@ -19,6 +19,7 @@
         "@suite-common/wallet-types": "workspace:*",
         "@trezor/connect": "workspace:*",
         "@walletconnect/core": "^2.18.1",
-        "@walletconnect/utils": "^2.18.1"
+        "@walletconnect/utils": "^2.18.1",
+        "bs58": "^6.0.0"
     }
 }
diff --git a/suite-common/walletconnect/src/adapters/ethereum.ts b/suite-common/walletconnect/src/adapters/ethereum.ts
index b85b58ac688..5539855fac3 100644
--- a/suite-common/walletconnect/src/adapters/ethereum.ts
+++ b/suite-common/walletconnect/src/adapters/ethereum.ts
@@ -1,18 +1,31 @@
 import { WalletKitTypes } from '@reown/walletkit';
+import type { ProposalTypes } from '@walletconnect/types';
 
 import * as trezorConnectPopupActions from '@suite-common/connect-popup';
 import { createThunk } from '@suite-common/redux-utils';
-import { getNetwork } from '@suite-common/wallet-config';
+import { Network, getNetwork, networksCollection } from '@suite-common/wallet-config';
 import { selectAccounts, selectSelectedDevice } from '@suite-common/wallet-core';
 import { ethereumGetCurrentNonceThunk } from '@suite-common/wallet-core/src/send/sendFormEthereumThunks';
+import { Account } from '@suite-common/wallet-types';
 import { getAccountIdentity, getEthereumEstimateFeeParams } from '@suite-common/wallet-utils';
 import TrezorConnect from '@trezor/connect';
 
 import { WALLETCONNECT_MODULE } from '../walletConnectConstants';
-import { WalletConnectAdapter } from '../walletConnectTypes';
+import {
+    PendingConnectionProposalNetwork,
+    WalletConnectAdapter,
+    WalletConnectNamespace,
+} from '../walletConnectTypes';
+
+const methods = [
+    'eth_sendTransaction',
+    'eth_signTypedData_v4',
+    'personal_sign',
+    'wallet_switchEthereumChain',
+];
 
 const ethereumRequestThunk = createThunk<
-    void,
+    string | undefined,
     {
         event: WalletKitTypes.SessionRequest;
     }
@@ -176,13 +189,75 @@ const ethereumRequestThunk = createThunk<
     }
 });
 
+export const getChainId = (network: Network) => [`eip155:${network.chainId}`];
+
+export const getNamespace = (accounts: Account[]) => {
+    const eip155 = {
+        chains: [],
+        accounts: [],
+        methods,
+        events: ['chainChanged', 'accountsChanged'],
+    } as WalletConnectNamespace;
+
+    accounts.forEach(account => {
+        const network = getNetwork(account.symbol);
+        const { networkType } = network;
+
+        if (!account.visible || networkType !== 'ethereum') return;
+
+        const walletConnectChainIds = getChainId(network);
+        for (const walletConnectChainId of walletConnectChainIds) {
+            if (!eip155.chains.includes(walletConnectChainId)) {
+                eip155.chains.push(walletConnectChainId);
+            }
+            eip155.accounts.push(`${walletConnectChainId}:${account.descriptor}`);
+        }
+    });
+
+    return { eip155 };
+};
+
+const processNamespaces = (
+    accounts: Account[],
+    networks: PendingConnectionProposalNetwork[],
+    namespaces: ProposalTypes.RequiredNamespaces,
+    required: boolean,
+) =>
+    Object.entries(namespaces).forEach(
+        ([key, namespace]: [string, ProposalTypes.RequiredNamespace]) => {
+            if (key === 'eip155') {
+                namespace.chains?.forEach(chain => {
+                    const alreadyAdded = networks.some(network => network.namespaceId === chain);
+                    if (alreadyAdded) return;
+                    const supported = networksCollection.find(
+                        nc => chain === `eip155:${nc.chainId}`,
+                    );
+                    const getStatus = () => {
+                        if (!supported) return 'unsupported';
+                        const hasAccounts = accounts.some(
+                            account => account.symbol === supported?.symbol,
+                        );
+                        if (hasAccounts) return 'active';
+
+                        return 'inactive';
+                    };
+                    networks.push({
+                        namespaceId: chain,
+                        symbol: supported?.symbol,
+                        name: supported?.name ?? `Unknown (${chain})`,
+                        status: getStatus(),
+                        required,
+                    });
+                });
+            }
+        },
+    );
+
 export const ethereumAdapter = {
-    methods: [
-        'eth_sendTransaction',
-        'eth_signTypedData_v4',
-        'personal_sign',
-        'wallet_switchEthereumChain',
-    ],
+    methods,
     networkType: 'ethereum',
     requestThunk: ethereumRequestThunk,
+    getNamespace,
+    getChainId,
+    processNamespaces,
 } satisfies WalletConnectAdapter;
diff --git a/suite-common/walletconnect/src/adapters/index.ts b/suite-common/walletconnect/src/adapters/index.ts
index 85c0f50a351..d7d79768f89 100644
--- a/suite-common/walletconnect/src/adapters/index.ts
+++ b/suite-common/walletconnect/src/adapters/index.ts
@@ -1,12 +1,14 @@
-import { getNetwork } from '@suite-common/wallet-config';
+import type { ProposalTypes } from '@walletconnect/types';
+
 import { Account } from '@suite-common/wallet-types';
 
 import { ethereumAdapter } from './ethereum';
-import { WalletConnectAdapter, WalletConnectNamespace } from '../walletConnectTypes';
+import { solanaAdapter } from './solana';
+import { PendingConnectionProposalNetwork, WalletConnectAdapter } from '../walletConnectTypes';
 
 export const adapters: WalletConnectAdapter[] = [
     ethereumAdapter,
-    // TODO: solanaAdapter
+    solanaAdapter,
     // TODO: bitcoinAdapter
 ];
 
@@ -18,26 +20,21 @@ export const getAdapterByNetwork = (networkType: string) =>
 
 export const getAllMethods = () => adapters.flatMap(adapter => adapter.methods);
 
-export const getNamespaces = (accounts: Account[]) => {
-    const eip155 = {
-        chains: [],
-        accounts: [],
-        methods: getAllMethods(),
-        events: ['accountsChanged', 'chainChanged'],
-    } as WalletConnectNamespace;
-
-    accounts.forEach(account => {
-        const network = getNetwork(account.symbol);
-        const { chainId, networkType } = network;
-
-        if (!account.visible || !getAdapterByNetwork(networkType)) return;
-
-        const walletConnectChainId = `eip155:${chainId}`;
-        if (!eip155.chains.includes(walletConnectChainId)) {
-            eip155.chains.push(walletConnectChainId);
-        }
-        eip155.accounts.push(`${walletConnectChainId}:${account.descriptor}`);
-    });
-
-    return { eip155 };
-};
+export const getNamespaces = (accounts: Account[]) =>
+    adapters
+        .map(adapter => adapter.getNamespace(accounts))
+        .reduce((acc, val) => {
+            Object.assign(acc, val);
+
+            return acc;
+        }, {});
+
+export const processNamespaces = (
+    accounts: Account[],
+    networks: PendingConnectionProposalNetwork[],
+    namespaces: ProposalTypes.RequiredNamespaces,
+    required: boolean,
+) =>
+    adapters.forEach(adapter =>
+        adapter.processNamespaces(accounts, networks, namespaces, required),
+    );
diff --git a/suite-common/walletconnect/src/adapters/solana.ts b/suite-common/walletconnect/src/adapters/solana.ts
new file mode 100644
index 00000000000..f5a6b9eef11
--- /dev/null
+++ b/suite-common/walletconnect/src/adapters/solana.ts
@@ -0,0 +1,223 @@
+import { WalletKitTypes } from '@reown/walletkit';
+import type { ProposalTypes } from '@walletconnect/types';
+import bs58 from 'bs58';
+
+import * as trezorConnectPopupActions from '@suite-common/connect-popup';
+import { createThunk } from '@suite-common/redux-utils';
+import { Network, getNetwork, networksCollection } from '@suite-common/wallet-config';
+import { selectAccounts, selectSelectedDevice } from '@suite-common/wallet-core';
+import { Account } from '@suite-common/wallet-types';
+import TrezorConnect from '@trezor/connect';
+
+import { WALLETCONNECT_MODULE } from '../walletConnectConstants';
+import {
+    PendingConnectionProposalNetwork,
+    WalletConnectAdapter,
+    WalletConnectNamespace,
+} from '../walletConnectTypes';
+
+const methods = [
+    'solana_getAccounts',
+    'solana_requestAccounts',
+    'solana_signTransaction',
+    'solana_signAndSendTransaction',
+    'solana_signMessage',
+];
+
+const solanaSignTransaction = createThunk<
+    { signature: string; transaction: string },
+    { transaction: string; feePayer?: string; origin: string }
+>(
+    `${WALLETCONNECT_MODULE}/solanaRequest`,
+    async ({ transaction, feePayer, origin }, { dispatch, getState }) => {
+        // Convert from base64 to hex
+        const transactionBuffer = Buffer.from(transaction, 'base64');
+        const serializedTx = transactionBuffer.toString('hex');
+
+        const device = selectSelectedDevice(getState());
+        const accounts = selectAccounts(getState());
+        const estimatedFee = await TrezorConnect.blockchainEstimateFee({
+            coin: 'sol',
+            request: {
+                specific: {
+                    data: serializedTx,
+                },
+            },
+        });
+        if (!estimatedFee.success) {
+            throw new Error('Failed to estimate fee');
+        }
+        // Get from argument or use decoded from estimate fee
+        feePayer = feePayer || estimatedFee.payload.levels[0].feePayer;
+        const account = accounts.find(
+            a => a.networkType === 'solana' && a.visible && a.descriptor === feePayer,
+        );
+        if (!account) {
+            throw new Error('Account not found');
+        }
+
+        const response = await dispatch(
+            trezorConnectPopupActions.connectPopupCallThunk({
+                method: 'solanaSignTransaction',
+                payload: {
+                    path: account.path,
+                    device,
+                    useEmptyPassphrase: device?.useEmptyPassphrase,
+                    serializedTx,
+                    serialize: true,
+                },
+                processName: 'WalletConnect',
+                origin,
+            }),
+        ).unwrap();
+        if (!response.success || !response.payload.serializedTx) {
+            console.error('solana_signTransaction error', response);
+            throw new Error('solana_signTransaction error');
+        }
+
+        return {
+            signature: response.payload.signature,
+            transaction: response.payload.serializedTx,
+        };
+    },
+);
+
+const solanaRequestThunk = createThunk<
+    { pubkey: string }[] | { signature: string } | undefined,
+    {
+        event: WalletKitTypes.SessionRequest;
+    }
+>(`${WALLETCONNECT_MODULE}/solanaRequest`, async ({ event }, { dispatch, getState }) => {
+    switch (event.params.request.method) {
+        case 'solana_getAccounts':
+        case 'solana_requestAccounts': {
+            const accounts = selectAccounts(getState());
+
+            return accounts
+                .filter(a => a.networkType === 'solana' && a.visible)
+                .map(a => ({ pubkey: a.descriptor }));
+        }
+        case 'solana_signTransaction': {
+            const { transaction, feePayer } = event.params.request.params;
+            const { origin } = event.verifyContext.verified;
+
+            const response = await dispatch(
+                solanaSignTransaction({ transaction, feePayer, origin }),
+            ).unwrap();
+
+            const signature = bs58.encode(Buffer.from(response.signature, 'hex'));
+
+            return { signature };
+        }
+        case 'solana_signAndSendTransaction': {
+            const { transaction } = event.params.request.params;
+            const { origin } = event.verifyContext.verified;
+
+            const signResponse = await dispatch(
+                solanaSignTransaction({ transaction, origin }),
+            ).unwrap();
+
+            const pushResponse = await TrezorConnect.pushTransaction({
+                // NOTE: I don't see any parameter that would determine devnet/mainnet
+                coin: 'sol',
+                tx: signResponse.transaction,
+            });
+            if (!pushResponse.success) {
+                console.error('eth_sendTransaction push error', pushResponse);
+                throw new Error('eth_sendTransaction push error');
+            }
+
+            return { signature: pushResponse.payload.txid };
+        }
+        case 'solana_signMessage': {
+            // Signing arbitrary messages for Solana is not supported in FW
+            // We indicate support for it in the adapter for compatibility, since some apps request it but don't actually use it
+            throw new Error('solana_signMessage not supported');
+        }
+    }
+});
+
+// https://github.com/reown-com/blockchain-api/blob/master/SUPPORTED_CHAINS.md#solana
+enum SolanaChainIds {
+    MAINNET = 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    TESTNET = 'solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1',
+    MAINNET_LEGACY = 'solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ',
+}
+
+export const getChainId = (network: Network) =>
+    network.testnet
+        ? [SolanaChainIds.TESTNET]
+        : [SolanaChainIds.MAINNET, SolanaChainIds.MAINNET_LEGACY];
+
+export const getNamespace = (accounts: Account[]) => {
+    const solana = {
+        chains: [],
+        accounts: [],
+        methods,
+        events: ['accountsChanged'],
+    } as WalletConnectNamespace;
+
+    accounts.forEach(account => {
+        const network = getNetwork(account.symbol);
+        const { networkType } = network;
+
+        if (!account.visible || networkType !== 'solana') return;
+
+        const walletConnectChainIds = getChainId(network);
+        for (const walletConnectChainId of walletConnectChainIds) {
+            if (!solana.chains.includes(walletConnectChainId)) {
+                solana.chains.push(walletConnectChainId);
+            }
+            solana.accounts.push(`${walletConnectChainId}:${account.descriptor}`);
+        }
+    });
+
+    return { solana };
+};
+
+const processNamespaces = (
+    accounts: Account[],
+    networks: PendingConnectionProposalNetwork[],
+    namespaces: ProposalTypes.RequiredNamespaces,
+    required: boolean,
+) =>
+    Object.entries(namespaces).forEach(
+        ([key, namespace]: [string, ProposalTypes.RequiredNamespace]) => {
+            if (key === 'solana') {
+                namespace.chains?.forEach(chain => {
+                    const supported = networksCollection
+                        .filter(nc => nc.networkType === 'solana')
+                        .find(nc => getChainId(nc).includes(chain as SolanaChainIds));
+                    const alreadyAdded = networks.some(
+                        network => network.symbol === supported?.symbol,
+                    );
+                    if (alreadyAdded) return;
+                    const getStatus = () => {
+                        if (!supported) return 'unsupported';
+                        const hasAccounts = accounts.some(
+                            account => account.symbol === supported?.symbol,
+                        );
+                        if (hasAccounts) return 'active';
+
+                        return 'inactive';
+                    };
+                    networks.push({
+                        namespaceId: chain,
+                        symbol: supported?.symbol,
+                        name: supported?.name ?? `Unknown (${chain})`,
+                        status: getStatus(),
+                        required,
+                    });
+                });
+            }
+        },
+    );
+
+export const solanaAdapter = {
+    methods,
+    networkType: 'solana',
+    requestThunk: solanaRequestThunk,
+    getChainId,
+    getNamespace,
+    processNamespaces,
+} satisfies WalletConnectAdapter;
diff --git a/suite-common/walletconnect/src/walletConnectThunks.ts b/suite-common/walletconnect/src/walletConnectThunks.ts
index 113b67fb345..71f7c295db9 100644
--- a/suite-common/walletconnect/src/walletConnectThunks.ts
+++ b/suite-common/walletconnect/src/walletConnectThunks.ts
@@ -1,7 +1,6 @@
 import { WalletKit, WalletKitTypes } from '@reown/walletkit';
 import { WalletKit as WalletKitClient } from '@reown/walletkit/dist/types/client';
 import { Core } from '@walletconnect/core';
-import type { ProposalTypes } from '@walletconnect/types';
 import {
     buildApprovedNamespaces,
     buildAuthObject,
@@ -11,12 +10,17 @@ import {
 
 import { createThunk } from '@suite-common/redux-utils';
 import { notificationsActions } from '@suite-common/toast-notifications';
-import { getNetwork, networksCollection } from '@suite-common/wallet-config';
+import { getNetwork } from '@suite-common/wallet-config';
 import { selectAccounts, selectSelectedDevice } from '@suite-common/wallet-core';
 import { Account } from '@suite-common/wallet-types';
 import TrezorConnect from '@trezor/connect';
 
-import { getAdapterByMethod, getNamespaces } from './adapters';
+import {
+    getAdapterByMethod,
+    getAdapterByNetwork,
+    getNamespaces,
+    processNamespaces,
+} from './adapters';
 import { walletConnectActions } from './walletConnectActions';
 import { PROJECT_ID, WALLETCONNECT_METADATA, WALLETCONNECT_MODULE } from './walletConnectConstants';
 import { selectPendingProposal } from './walletConnectReducer';
@@ -93,37 +97,8 @@ export const sessionProposalThunk = createThunk<
     // Check supported networks
     const accounts = selectAccounts(getState());
     const networks: PendingConnectionProposalNetwork[] = [];
-    const processNamespace =
-        (required: boolean) =>
-        ([key, namespace]: [string, ProposalTypes.RequiredNamespace]) => {
-            if (key === 'eip155') {
-                namespace.chains?.forEach(chain => {
-                    const alreadyAdded = networks.some(network => network.namespaceId === chain);
-                    if (alreadyAdded) return;
-                    const supported = networksCollection.find(
-                        nc => chain === `eip155:${nc.chainId}`,
-                    );
-                    const getStatus = () => {
-                        if (!supported) return 'unsupported';
-                        const hasAccounts = accounts.some(
-                            account => account.symbol === supported?.symbol,
-                        );
-                        if (hasAccounts) return 'active';
-
-                        return 'inactive';
-                    };
-                    networks.push({
-                        namespaceId: chain,
-                        symbol: supported?.symbol,
-                        name: supported?.name ?? `Unknown (${chain})`,
-                        status: getStatus(),
-                        required,
-                    });
-                });
-            }
-        };
-    Object.entries(event.params.requiredNamespaces).forEach(processNamespace(true));
-    Object.entries(event.params.optionalNamespaces).forEach(processNamespace(false));
+    processNamespaces(accounts, networks, event.params.requiredNamespaces, true);
+    processNamespaces(accounts, networks, event.params.optionalNamespaces, false);
 
     dispatch(
         walletConnectActions.createSessionProposal({
@@ -150,6 +125,7 @@ export const sessionRequestThunk = createThunk<
 
         const result = await dispatch(adapter.requestThunk({ event }));
         if (!result || result.error) {
+            console.error(result);
             throw new Error('Device request failed');
         }
 
@@ -180,10 +156,11 @@ export const sessionProposalApproveThunk = createThunk<
     void,
     {
         eventId: number;
+        selectedDefaultAccounts?: Account[];
     }
 >(
     `${WALLETCONNECT_MODULE}/sessionProposalApproveThunk`,
-    async ({ eventId }, { dispatch, getState }) => {
+    async ({ eventId, selectedDefaultAccounts }, { dispatch, getState }) => {
         try {
             const pendingProposal = selectPendingProposal(getState());
             if (
@@ -195,7 +172,17 @@ export const sessionProposalApproveThunk = createThunk<
             }
 
             const accounts = selectAccounts(getState());
-            const supportedNamespaces = getNamespaces(accounts);
+            const accountsInPreferentialOrder = [...(selectedDefaultAccounts || [])];
+            accounts.forEach(account => {
+                if (
+                    !accountsInPreferentialOrder.some(
+                        a => a.descriptor === account.descriptor && a.symbol === account.symbol,
+                    )
+                ) {
+                    accountsInPreferentialOrder.push(account);
+                }
+            });
+            const supportedNamespaces = getNamespaces(accountsInPreferentialOrder);
             const approvedNamespaces = buildApprovedNamespaces({
                 proposal: pendingProposal.params,
                 supportedNamespaces,
@@ -252,22 +239,27 @@ export const switchSelectedAccountThunk = createThunk<void, { account: Account }
         const network = getNetwork(account.symbol);
         if (!network || !network.chainId) return;
         const sessions = await walletKit.getActiveSessions();
+        const chainId = getAdapterByNetwork(network.networkType)?.getChainId(network)?.[0];
+        if (!chainId) return;
+
         for (const topic in sessions) {
-            walletKit.emitSessionEvent({
-                topic,
-                event: {
-                    name: 'chainChanged',
-                    data: network.chainId,
-                },
-                chainId: `eip155:${network.chainId}`,
-            });
+            if (network.chainId) {
+                walletKit.emitSessionEvent({
+                    topic,
+                    event: {
+                        name: 'chainChanged',
+                        data: network.chainId,
+                    },
+                    chainId,
+                });
+            }
             walletKit.emitSessionEvent({
                 topic,
                 event: {
                     name: 'accountsChanged',
                     data: [account.descriptor],
                 },
-                chainId: `eip155:${network.chainId}`,
+                chainId,
             });
         }
     },
@@ -282,14 +274,18 @@ export const updateAccountsThunk = createThunk(
         for (const topic in sessions) {
             const { namespaces: oldNamespaces } = sessions[topic];
             const updatedNamespaces = getNamespaces(accounts);
-            const namespaces = {
-                ...oldNamespaces,
-                eip155: {
-                    ...oldNamespaces.eip155,
-                    accounts: updatedNamespaces.eip155.accounts,
-                    chains: updatedNamespaces.eip155.chains,
+            const namespaces = Object.keys(oldNamespaces).reduce(
+                (acc, key) => {
+                    acc[key] = {
+                        ...oldNamespaces[key],
+                        accounts: updatedNamespaces[key].accounts ?? [],
+                        chains: updatedNamespaces[key].chains ?? [],
+                    };
+
+                    return acc;
                 },
-            };
+                { ...oldNamespaces },
+            );
             await walletKit.updateSession({
                 topic,
                 namespaces,
diff --git a/suite-common/walletconnect/src/walletConnectTypes.ts b/suite-common/walletconnect/src/walletConnectTypes.ts
index d1368599f76..bac5e5686ab 100644
--- a/suite-common/walletconnect/src/walletConnectTypes.ts
+++ b/suite-common/walletconnect/src/walletConnectTypes.ts
@@ -2,6 +2,8 @@ import { WalletKitTypes } from '@reown/walletkit';
 import type { ProposalTypes } from '@walletconnect/types';
 
 import { SuiteCompatibleThunk } from '@suite-common/redux-utils';
+import { Network } from '@suite-common/wallet-config';
+import { Account } from '@suite-common/wallet-types';
 
 export interface WalletConnectAdapter {
     networkType: string;
@@ -9,6 +11,14 @@ export interface WalletConnectAdapter {
     requestThunk: SuiteCompatibleThunk<{
         event: WalletKitTypes.SessionRequest;
     }>;
+    getChainId: (network: Network) => string[];
+    getNamespace: (accounts: Account[]) => Record<string, WalletConnectNamespace>;
+    processNamespaces: (
+        accounts: Account[],
+        networks: PendingConnectionProposalNetwork[],
+        namespaces: ProposalTypes.RequiredNamespaces,
+        required: boolean,
+    ) => void;
 }
 
 export interface WalletConnectNamespace {
diff --git a/yarn.lock b/yarn.lock
index bfd35054c54..ed39ac01ee0 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9712,6 +9712,7 @@ __metadata:
     "@trezor/connect": "workspace:*"
     "@walletconnect/core": "npm:^2.18.1"
     "@walletconnect/utils": "npm:^2.18.1"
+    bs58: "npm:^6.0.0"
   languageName: unknown
   linkType: soft