diff --git a/apps/demo-wallet/src/components/IntentRequestModal.tsx b/apps/demo-wallet/src/components/IntentRequestModal.tsx
new file mode 100644
index 000000000..492ad9311
--- /dev/null
+++ b/apps/demo-wallet/src/components/IntentRequestModal.tsx
@@ -0,0 +1,527 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import React, { useState, useEffect, useMemo } from 'react';
+import type {
+    IntentRequestEvent,
+    BatchedIntentEvent,
+    TransactionIntentRequestEvent,
+    SignDataIntentRequestEvent,
+    ActionIntentRequestEvent,
+    IntentActionItem,
+    SendTonAction,
+    SendJettonAction,
+    SendNftAction,
+} from '@ton/walletkit';
+import { useAuth } from '@demo/wallet-core';
+import type { SavedWallet } from '@demo/wallet-core';
+import { Address } from '@ton/core';
+
+import { Button } from './Button';
+import { Card } from './Card';
+import { HoldToSignButton } from './HoldToSignButton';
+import { WalletPreview } from './WalletPreview';
+import { createComponentLogger } from '../utils/logger';
+
+const log = createComponentLogger('IntentRequestModal');
+
+// ==================== Shared Renderers ====================
+
+function truncateAddress(address: string): string {
+    try {
+        const addr = Address.parse(address);
+        const friendly = addr.toString();
+        return `${friendly.slice(0, 6)}...${friendly.slice(-4)}`;
+    } catch {
+        if (address.length > 16) {
+            return `${address.slice(0, 8)}...${address.slice(-4)}`;
+        }
+        return address;
+    }
+}
+
+function formatNano(amount: string): string {
+    const n = BigInt(amount);
+    const whole = n / 1_000_000_000n;
+    const frac = n % 1_000_000_000n;
+    if (frac === 0n) return `${whole}`;
+    const fracStr = frac.toString().padStart(9, '0').replace(/0+$/, '');
+    return `${whole}.${fracStr}`;
+}
+
+const ActionItemCard: React.FC<{ item: IntentActionItem; index: number }> = ({ item, index }) => {
+    switch (item.type) {
+        case 'sendTon': {
+            const action = item.value as SendTonAction;
+            return (
+                <div className="border rounded-lg p-3 bg-blue-50">
+                    <div className="flex items-center gap-2 mb-2">
+                        <span className="text-xs font-semibold bg-blue-200 text-blue-800 px-2 py-0.5 rounded">
+                            #{index + 1} Send TON
+                        </span>
+                    </div>
+                    <div className="space-y-1 text-sm">
+                        <p>
+                            <span className="font-medium">To:</span>{' '}
+                            <span className="font-mono text-xs">{truncateAddress(action.address)}</span>
+                        </p>
+                        <p>
+                            <span className="font-medium">Amount:</span> {formatNano(action.amount)} TON
+                        </p>
+                        {action.payload && (
+                            <p className="text-xs text-gray-500 truncate">
+                                <span className="font-medium">Payload:</span> {action.payload}
+                            </p>
+                        )}
+                    </div>
+                </div>
+            );
+        }
+        case 'sendJetton': {
+            const action = item.value as SendJettonAction;
+            return (
+                <div className="border rounded-lg p-3 bg-purple-50">
+                    <div className="flex items-center gap-2 mb-2">
+                        <span className="text-xs font-semibold bg-purple-200 text-purple-800 px-2 py-0.5 rounded">
+                            #{index + 1} Send Jetton
+                        </span>
+                    </div>
+                    <div className="space-y-1 text-sm">
+                        <p>
+                            <span className="font-medium">Master:</span>{' '}
+                            <span className="font-mono text-xs">{truncateAddress(action.jettonMasterAddress)}</span>
+                        </p>
+                        <p>
+                            <span className="font-medium">Amount:</span> {action.jettonAmount}
+                        </p>
+                        <p>
+                            <span className="font-medium">To:</span>{' '}
+                            <span className="font-mono text-xs">{truncateAddress(action.destination)}</span>
+                        </p>
+                        {action.forwardTonAmount && (
+                            <p>
+                                <span className="font-medium">Forward TON:</span> {formatNano(action.forwardTonAmount)}
+                            </p>
+                        )}
+                    </div>
+                </div>
+            );
+        }
+        case 'sendNft': {
+            const action = item.value as SendNftAction;
+            return (
+                <div className="border rounded-lg p-3 bg-amber-50">
+                    <div className="flex items-center gap-2 mb-2">
+                        <span className="text-xs font-semibold bg-amber-200 text-amber-800 px-2 py-0.5 rounded">
+                            #{index + 1} Send NFT
+                        </span>
+                    </div>
+                    <div className="space-y-1 text-sm">
+                        <p>
+                            <span className="font-medium">NFT:</span>{' '}
+                            <span className="font-mono text-xs">{truncateAddress(action.nftAddress)}</span>
+                        </p>
+                        <p>
+                            <span className="font-medium">New Owner:</span>{' '}
+                            <span className="font-mono text-xs">{truncateAddress(action.newOwnerAddress)}</span>
+                        </p>
+                    </div>
+                </div>
+            );
+        }
+        default:
+            return (
+                <div className="border rounded-lg p-3 bg-gray-50">
+                    <p className="text-sm text-gray-600">Unknown action type</p>
+                </div>
+            );
+    }
+};
+
+const IntentEventDetails: React.FC<{ event: IntentRequestEvent }> = ({ event }) => {
+    switch (event.type) {
+        case 'transaction': {
+            const tx = event.value as TransactionIntentRequestEvent;
+            return (
+                <div className="space-y-3">
+                    <div className="flex items-center gap-2">
+                        <span className="text-xs font-semibold bg-indigo-100 text-indigo-800 px-2 py-0.5 rounded">
+                            Transaction
+                        </span>
+                        <span className="text-xs text-gray-500">
+                            delivery: <span className="font-medium">{tx.deliveryMode}</span>
+                        </span>
+                        {tx.network && <span className="text-xs text-gray-500">network: {tx.network.chainId}</span>}
+                    </div>
+                    {tx.validUntil && (
+                        <p className="text-xs text-gray-500">
+                            Valid until: {new Date(tx.validUntil * 1000).toLocaleString()}
+                        </p>
+                    )}
+                    <div className="space-y-2">
+                        {tx.items.map((item, i) => (
+                            <ActionItemCard key={i} item={item} index={i} />
+                        ))}
+                    </div>
+                </div>
+            );
+        }
+        case 'signData': {
+            const sd = event.value as SignDataIntentRequestEvent;
+            return (
+                <div className="space-y-3">
+                    <div className="flex items-center gap-2">
+                        <span className="text-xs font-semibold bg-green-100 text-green-800 px-2 py-0.5 rounded">
+                            Sign Data
+                        </span>
+                        {sd.network && <span className="text-xs text-gray-500">network: {sd.network.chainId}</span>}
+                    </div>
+                    {sd.manifestUrl && <p className="text-xs text-gray-500 truncate">Manifest: {sd.manifestUrl}</p>}
+                    <div className="border rounded-lg p-3 bg-green-50">
+                        <p className="text-sm font-medium mb-1">Payload</p>
+                        <pre className="text-xs overflow-x-auto whitespace-pre-wrap bg-white/50 p-2 rounded">
+                            {JSON.stringify(sd.payload, null, 2)}
+                        </pre>
+                    </div>
+                </div>
+            );
+        }
+        case 'action': {
+            const action = event.value as ActionIntentRequestEvent;
+            return (
+                <div className="space-y-3">
+                    <span className="text-xs font-semibold bg-orange-100 text-orange-800 px-2 py-0.5 rounded">
+                        Action
+                    </span>
+                    <p className="text-sm break-all">
+                        <span className="font-medium">URL:</span> {action.actionUrl}
+                    </p>
+                </div>
+            );
+        }
+        default:
+            return <p className="text-sm text-gray-500">Unknown intent type</p>;
+    }
+};
+
+// ==================== Single Intent Modal ====================
+
+interface IntentRequestModalProps {
+    event: IntentRequestEvent;
+    savedWallets: SavedWallet[];
+    isOpen: boolean;
+    onApprove: () => Promise<void>;
+    onReject: (reason?: string) => Promise<void>;
+}
+
+export const IntentRequestModal: React.FC<IntentRequestModalProps> = ({
+    event,
+    savedWallets,
+    isOpen,
+    onApprove,
+    onReject,
+}) => {
+    const [isLoading, setIsLoading] = useState(false);
+    const [showSuccess, setShowSuccess] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const { holdToSign } = useAuth();
+
+    const currentWallet = useMemo(() => {
+        return savedWallets[0] || null;
+    }, [savedWallets]);
+
+    useEffect(() => {
+        if (!isOpen) {
+            setShowSuccess(false);
+            setIsLoading(false);
+            setError(null);
+        }
+    }, [isOpen]);
+
+    const handleApprove = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            await onApprove();
+            setIsLoading(false);
+            setShowSuccess(true);
+        } catch (err) {
+            log.error('Failed to approve intent:', err);
+            setIsLoading(false);
+            setError(err instanceof Error ? err.message : 'Failed to approve');
+        }
+    };
+
+    const handleReject = async () => {
+        try {
+            await onReject('User declined');
+        } catch (err) {
+            log.error('Failed to reject intent:', err);
+        }
+    };
+
+    if (!isOpen) return null;
+
+    if (showSuccess) {
+        return (
+            <div className="fixed inset-0 bg-black/50 flex items-center justify-center p-4 z-50">
+                <div className="bg-gradient-to-br from-green-400 to-green-600 rounded-lg max-w-md w-full p-8 text-center text-white">
+                    <div className="flex justify-center mb-4">
+                        <div className="bg-white rounded-full p-4">
+                            <svg
+                                className="w-16 h-16 text-green-500"
+                                fill="none"
+                                stroke="currentColor"
+                                viewBox="0 0 24 24"
+                            >
+                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={3} d="M5 13l4 4L19 7" />
+                            </svg>
+                        </div>
+                    </div>
+                    <h2 className="text-3xl font-bold mb-2">Success!</h2>
+                    <p className="text-green-50 text-lg">Intent approved</p>
+                </div>
+            </div>
+        );
+    }
+
+    return (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center p-4 z-50">
+            <div className="bg-white rounded-lg max-w-md w-full max-h-[90vh] overflow-y-auto">
+                <Card>
+                    <div className="space-y-6">
+                        {/* Header */}
+                        <div className="text-center">
+                            <div className="mx-auto w-12 h-12 bg-indigo-100 rounded-full flex items-center justify-center mb-3">
+                                <svg
+                                    className="w-6 h-6 text-indigo-600"
+                                    fill="none"
+                                    viewBox="0 0 24 24"
+                                    stroke="currentColor"
+                                >
+                                    <path
+                                        strokeLinecap="round"
+                                        strokeLinejoin="round"
+                                        strokeWidth={2}
+                                        d="M13 10V3L4 14h7v7l9-11h-7z"
+                                    />
+                                </svg>
+                            </div>
+                            <h3 className="text-lg font-bold text-gray-900">Intent Request</h3>
+                            <p className="text-sm text-gray-500 mt-1">
+                                Type: <span className="font-medium">{event.type}</span>
+                            </p>
+                        </div>
+
+                        {/* Wallet Info */}
+                        {currentWallet && <WalletPreview wallet={currentWallet} isCompact />}
+
+                        {/* Intent details */}
+                        <IntentEventDetails event={event} />
+
+                        {/* Error */}
+                        {error && <div className="text-red-600 text-sm text-center p-2 bg-red-50 rounded">{error}</div>}
+
+                        {/* Actions */}
+                        <div className="flex gap-3">
+                            <Button variant="secondary" onClick={handleReject} className="flex-1" disabled={isLoading}>
+                                Reject
+                            </Button>
+                            {holdToSign ? (
+                                <HoldToSignButton
+                                    onComplete={handleApprove}
+                                    disabled={isLoading}
+                                    isLoading={isLoading}
+                                    className="flex-1"
+                                />
+                            ) : (
+                                <Button onClick={handleApprove} className="flex-1" disabled={isLoading}>
+                                    {isLoading ? 'Approving...' : 'Approve'}
+                                </Button>
+                            )}
+                        </div>
+                    </div>
+                </Card>
+            </div>
+        </div>
+    );
+};
+
+// ==================== Batched Intent Modal ====================
+
+interface BatchedIntentRequestModalProps {
+    batch: BatchedIntentEvent;
+    savedWallets: SavedWallet[];
+    isOpen: boolean;
+    onApprove: () => Promise<void>;
+    onReject: (reason?: string) => Promise<void>;
+}
+
+export const BatchedIntentRequestModal: React.FC<BatchedIntentRequestModalProps> = ({
+    batch,
+    savedWallets,
+    isOpen,
+    onApprove,
+    onReject,
+}) => {
+    const [isLoading, setIsLoading] = useState(false);
+    const [showSuccess, setShowSuccess] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const { holdToSign } = useAuth();
+
+    const currentWallet = useMemo(() => {
+        return savedWallets[0] || null;
+    }, [savedWallets]);
+
+    useEffect(() => {
+        if (!isOpen) {
+            setShowSuccess(false);
+            setIsLoading(false);
+            setError(null);
+        }
+    }, [isOpen]);
+
+    const handleApprove = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            await onApprove();
+            setIsLoading(false);
+            setShowSuccess(true);
+        } catch (err) {
+            log.error('Failed to approve batched intent:', err);
+            setIsLoading(false);
+            setError(err instanceof Error ? err.message : 'Failed to approve');
+        }
+    };
+
+    const handleReject = async () => {
+        try {
+            await onReject('User declined');
+        } catch (err) {
+            log.error('Failed to reject batched intent:', err);
+        }
+    };
+
+    // Filter out connect intents for display (they're auto-handled)
+    const displayIntents = useMemo(() => {
+        return batch.intents.filter((i) => i.type !== 'connect');
+    }, [batch.intents]);
+
+    const connectIntents = useMemo(() => {
+        return batch.intents.filter((i) => i.type === 'connect');
+    }, [batch.intents]);
+
+    if (!isOpen) return null;
+
+    if (showSuccess) {
+        return (
+            <div className="fixed inset-0 bg-black/50 flex items-center justify-center p-4 z-50">
+                <div className="bg-gradient-to-br from-green-400 to-green-600 rounded-lg max-w-md w-full p-8 text-center text-white">
+                    <div className="flex justify-center mb-4">
+                        <div className="bg-white rounded-full p-4">
+                            <svg
+                                className="w-16 h-16 text-green-500"
+                                fill="none"
+                                stroke="currentColor"
+                                viewBox="0 0 24 24"
+                            >
+                                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={3} d="M5 13l4 4L19 7" />
+                            </svg>
+                        </div>
+                    </div>
+                    <h2 className="text-3xl font-bold mb-2">Success!</h2>
+                    <p className="text-green-50 text-lg">Batched intent approved</p>
+                </div>
+            </div>
+        );
+    }
+
+    return (
+        <div className="fixed inset-0 bg-black/50 flex items-center justify-center p-4 z-50">
+            <div className="bg-white rounded-lg max-w-md w-full max-h-[90vh] overflow-y-auto">
+                <Card>
+                    <div className="space-y-6">
+                        {/* Header */}
+                        <div className="text-center">
+                            <div className="mx-auto w-12 h-12 bg-orange-100 rounded-full flex items-center justify-center mb-3">
+                                <svg
+                                    className="w-6 h-6 text-orange-600"
+                                    fill="none"
+                                    viewBox="0 0 24 24"
+                                    stroke="currentColor"
+                                >
+                                    <path
+                                        strokeLinecap="round"
+                                        strokeLinejoin="round"
+                                        strokeWidth={2}
+                                        d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10"
+                                    />
+                                </svg>
+                            </div>
+                            <h3 className="text-lg font-bold text-gray-900">Batched Intent Request</h3>
+                            <p className="text-sm text-gray-500 mt-1">
+                                Origin: <span className="font-medium">{batch.origin}</span>
+                                {' · '}
+                                {batch.intents.length} intent{batch.intents.length !== 1 ? 's' : ''}
+                            </p>
+                        </div>
+
+                        {/* Wallet Info */}
+                        {currentWallet && <WalletPreview wallet={currentWallet} isCompact />}
+
+                        {/* Connect info if present */}
+                        {connectIntents.length > 0 && (
+                            <div className="border rounded-lg p-3 bg-yellow-50">
+                                <p className="text-xs font-semibold text-yellow-800 mb-1">
+                                    Includes {connectIntents.length} connect request
+                                    {connectIntents.length > 1 ? 's' : ''}
+                                </p>
+                                <p className="text-xs text-yellow-700">
+                                    A dApp connection will be established on approval.
+                                </p>
+                            </div>
+                        )}
+
+                        {/* Each intent */}
+                        <div className="space-y-4">
+                            {displayIntents.map((intent, i) => (
+                                <div key={i} className="border rounded-lg p-3 bg-gray-50">
+                                    <p className="text-xs text-gray-500 mb-2">Intent {i + 1}</p>
+                                    <IntentEventDetails event={intent} />
+                                </div>
+                            ))}
+                        </div>
+
+                        {/* Error */}
+                        {error && <div className="text-red-600 text-sm text-center p-2 bg-red-50 rounded">{error}</div>}
+
+                        {/* Actions */}
+                        <div className="flex gap-3">
+                            <Button variant="secondary" onClick={handleReject} className="flex-1" disabled={isLoading}>
+                                Reject
+                            </Button>
+                            {holdToSign ? (
+                                <HoldToSignButton
+                                    onComplete={handleApprove}
+                                    disabled={isLoading}
+                                    isLoading={isLoading}
+                                    className="flex-1"
+                                />
+                            ) : (
+                                <Button onClick={handleApprove} className="flex-1" disabled={isLoading}>
+                                    {isLoading ? 'Approving...' : 'Approve'}
+                                </Button>
+                            )}
+                        </div>
+                    </div>
+                </Card>
+            </div>
+        </div>
+    );
+};
diff --git a/apps/demo-wallet/src/components/index.ts b/apps/demo-wallet/src/components/index.ts
index d55b351f1..de110e895 100644
--- a/apps/demo-wallet/src/components/index.ts
+++ b/apps/demo-wallet/src/components/index.ts
@@ -28,6 +28,7 @@ export { SettingsDropdown } from './SettingsDropdown';
 export { ProtectedRoute } from './ProtectedRoute';
 export { RecentTransactions } from './RecentTransactions';
 export { SignDataRequestModal } from './SignDataRequestModal';
+export { IntentRequestModal, BatchedIntentRequestModal } from './IntentRequestModal';
 export { TraceRow } from './TraceRow';
 export { TransactionRequestModal } from './TransactionRequestModal';
 export { WalletPreview } from './WalletPreview';
diff --git a/apps/demo-wallet/src/pages/WalletDashboard.tsx b/apps/demo-wallet/src/pages/WalletDashboard.tsx
index 8a3f1fd48..aca4844b4 100644
--- a/apps/demo-wallet/src/pages/WalletDashboard.tsx
+++ b/apps/demo-wallet/src/pages/WalletDashboard.tsx
@@ -8,7 +8,14 @@
 
 import React, { useState, useCallback } from 'react';
 import { useNavigate } from 'react-router-dom';
-import { useWallet, useWalletKit, useTonConnect, useTransactionRequests, useSignDataRequests } from '@demo/wallet-core';
+import {
+    useWallet,
+    useWalletKit,
+    useTonConnect,
+    useTransactionRequests,
+    useSignDataRequests,
+    useIntents,
+} from '@demo/wallet-core';
 
 import {
     Layout,
@@ -17,6 +24,8 @@ import {
     ConnectRequestModal,
     TransactionRequestModal,
     SignDataRequestModal,
+    IntentRequestModal,
+    BatchedIntentRequestModal,
     DisconnectNotifications,
     NftsCard,
     RecentTransactions,
@@ -62,10 +71,33 @@ export const WalletDashboard: React.FC = () => {
     const { pendingTransactionRequest, isTransactionModalOpen } = useTransactionRequests();
     const { pendingSignDataRequest, isSignDataModalOpen, approveSignDataRequest, rejectSignDataRequest } =
         useSignDataRequests();
+    const {
+        pendingIntentEvent,
+        pendingBatchedIntentEvent,
+        isIntentModalOpen,
+        isBatchedIntentModalOpen,
+        handleIntentUrl,
+        isIntentUrl,
+        approveIntent,
+        rejectIntent,
+        approveBatchedIntent,
+        rejectBatchedIntent,
+    } = useIntents();
     const { error } = useTonWallet();
 
-    // Use the paste handler hook
-    usePasteHandler(handleTonConnectUrl);
+    // Use the paste handler hook — route intent URLs to handleIntentUrl
+    const handlePastedUrl = useCallback(
+        async (url: string) => {
+            if (isIntentUrl(url)) {
+                log.info('Detected pasted intent URL, routing to intent handler');
+                await handleIntentUrl(url);
+            } else {
+                await handleTonConnectUrl(url);
+            }
+        },
+        [isIntentUrl, handleIntentUrl, handleTonConnectUrl],
+    );
+    usePasteHandler(handlePastedUrl);
 
     const handleRefreshBalance = useCallback(async () => {
         setIsRefreshing(true);
@@ -93,17 +125,22 @@ export const WalletDashboard: React.FC = () => {
     const handleConnectDApp = useCallback(async () => {
         if (!tonConnectUrl.trim()) return;
 
+        const url = tonConnectUrl.trim();
         setIsConnecting(true);
         try {
-            await handleTonConnectUrl(tonConnectUrl.trim());
+            if (isIntentUrl(url)) {
+                log.info('Detected intent URL, routing to intent handler');
+                await handleIntentUrl(url);
+            } else {
+                await handleTonConnectUrl(url);
+            }
             setTonConnectUrl('');
         } catch (err) {
-            log.error('Failed to connect to dApp:', err);
-            // TODO: Show error message to user
+            log.error('Failed to process URL:', err);
         } finally {
             setIsConnecting(false);
         }
-    }, [tonConnectUrl, handleTonConnectUrl]);
+    }, [tonConnectUrl, handleTonConnectUrl, isIntentUrl, handleIntentUrl]);
 
     const handleTestDisconnectAll = useCallback(async () => {
         if (!walletKit) return;
@@ -286,18 +323,18 @@ export const WalletDashboard: React.FC = () => {
                 <NftsCard />
 
                 {/* TON Connect URL Input */}
-                <Card title="Connect to dApp">
+                <Card title="Connect to dApp / Handle Intent">
                     <div className="space-y-4">
                         <div>
                             <label htmlFor="tonconnect-url" className="block text-sm font-medium text-gray-700 mb-2">
-                                Paste TON Connect Link
+                                Paste TON Connect or Intent Link
                             </label>
                             <textarea
                                 data-testid="tonconnect-url"
                                 id="tonconnect-url"
                                 rows={3}
                                 className="w-full px-3 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-blue-500 focus:border-blue-500 resize-none text-black"
-                                placeholder="tc://... or ton://... or https://..."
+                                placeholder="tc://... or ton://... or https://... or intent URL"
                                 value={tonConnectUrl}
                                 onChange={(e) => setTonConnectUrl(e.target.value)}
                             />
@@ -309,7 +346,9 @@ export const WalletDashboard: React.FC = () => {
                             disabled={!tonConnectUrl.trim() || isConnecting}
                             className="w-full"
                         >
-                            Connect to dApp
+                            {tonConnectUrl.trim() && isIntentUrl(tonConnectUrl.trim())
+                                ? 'Process Intent'
+                                : 'Connect to dApp'}
                         </Button>
                     </div>
                 </Card>
@@ -382,6 +421,28 @@ export const WalletDashboard: React.FC = () => {
                     onReject={rejectSignDataRequest}
                 />
             )}
+
+            {/* Intent Request Modal */}
+            {pendingIntentEvent && (
+                <IntentRequestModal
+                    event={pendingIntentEvent}
+                    savedWallets={savedWallets}
+                    isOpen={isIntentModalOpen}
+                    onApprove={approveIntent}
+                    onReject={rejectIntent}
+                />
+            )}
+
+            {/* Batched Intent Request Modal */}
+            {pendingBatchedIntentEvent && (
+                <BatchedIntentRequestModal
+                    batch={pendingBatchedIntentEvent}
+                    savedWallets={savedWallets}
+                    isOpen={isBatchedIntentModalOpen}
+                    onApprove={approveBatchedIntent}
+                    onReject={rejectBatchedIntent}
+                />
+            )}
         </Layout>
     );
 };
diff --git a/demo/wallet-core/src/hooks/useWalletStore.ts b/demo/wallet-core/src/hooks/useWalletStore.ts
index d3d6bd174..724884de8 100644
--- a/demo/wallet-core/src/hooks/useWalletStore.ts
+++ b/demo/wallet-core/src/hooks/useWalletStore.ts
@@ -229,3 +229,27 @@ export const useSwap = () => {
         })),
     );
 };
+
+/**
+ * Hook for Intent state and actions
+ */
+export const useIntents = () => {
+    return useWalletStore(
+        useShallow((state) => ({
+            pendingIntentEvent: state.intent.pendingIntentEvent,
+            pendingBatchedIntentEvent: state.intent.pendingBatchedIntentEvent,
+            isIntentModalOpen: state.intent.isIntentModalOpen,
+            isBatchedIntentModalOpen: state.intent.isBatchedIntentModalOpen,
+            intentResult: state.intent.intentResult,
+            intentError: state.intent.intentError,
+            handleIntentUrl: state.handleIntentUrl,
+            isIntentUrl: state.isIntentUrl,
+            approveIntent: state.approveIntent,
+            rejectIntent: state.rejectIntent,
+            approveBatchedIntent: state.approveBatchedIntent,
+            rejectBatchedIntent: state.rejectBatchedIntent,
+            closeIntentModal: state.closeIntentModal,
+            closeBatchedIntentModal: state.closeBatchedIntentModal,
+        })),
+    );
+};
diff --git a/demo/wallet-core/src/index.ts b/demo/wallet-core/src/index.ts
index 23cc7cd79..541851f40 100644
--- a/demo/wallet-core/src/index.ts
+++ b/demo/wallet-core/src/index.ts
@@ -30,6 +30,7 @@ export {
     useNfts,
     useJettons,
     useSwap,
+    useIntents,
 } from './hooks/useWalletStore';
 export { useFormattedTonBalance, useFormattedAmount } from './hooks/useFormattedBalance';
 export { useWalletInitialization } from './hooks/useWalletInitialization';
@@ -42,6 +43,7 @@ export type {
     WalletCoreSlice,
     WalletManagementSlice,
     TonConnectSlice,
+    IntentSlice,
     JettonsSlice,
     NftsSlice,
     SwapSlice,
diff --git a/demo/wallet-core/src/store/createWalletStore.ts b/demo/wallet-core/src/store/createWalletStore.ts
index 140df9cc1..324bbb5c6 100644
--- a/demo/wallet-core/src/store/createWalletStore.ts
+++ b/demo/wallet-core/src/store/createWalletStore.ts
@@ -17,6 +17,7 @@ import { createTonConnectSlice } from './slices/tonConnectSlice';
 import { createJettonsSlice } from './slices/jettonsSlice';
 import { createNftsSlice } from './slices/nftsSlice';
 import { createSwapSlice } from './slices/swapSlice';
+import { createIntentSlice } from './slices/intentSlice';
 import type { AppState } from '../types/store';
 import type { StorageAdapter } from '../adapters/storage/types';
 import type { WalletKitConfig } from '../types/wallet';
@@ -141,6 +142,9 @@ export function createWalletStore(options: CreateWalletStoreOptions = {}) {
                         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                         // @ts-ignore
                         ...createSwapSlice(...a),
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        ...createIntentSlice(...a),
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     })) as unknown as any,
                     {
diff --git a/demo/wallet-core/src/store/slices/intentSlice.ts b/demo/wallet-core/src/store/slices/intentSlice.ts
new file mode 100644
index 000000000..d54b883ad
--- /dev/null
+++ b/demo/wallet-core/src/store/slices/intentSlice.ts
@@ -0,0 +1,285 @@
+/**
+ * Copyright (c) TonTech.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+import type {
+    IntentRequestEvent,
+    BatchedIntentEvent,
+    TransactionIntentRequestEvent,
+    SignDataIntentRequestEvent,
+    ActionIntentRequestEvent,
+    IntentTransactionResponse,
+    IntentSignDataResponse,
+} from '@ton/walletkit';
+import { TonWalletKit } from '@ton/walletkit';
+
+import { createComponentLogger } from '../../utils/logger';
+import type { SetState, IntentSliceCreator } from '../../types/store';
+
+const log = createComponentLogger('IntentSlice');
+
+/**
+ * Deep-clone an object to break Immer frozen state before passing to SDK.
+ * SDK methods may mutate event objects internally.
+ */
+function cloneEvent<T>(obj: T): T {
+    return structuredClone(obj);
+}
+
+export const createIntentSlice: IntentSliceCreator = (set: SetState, get) => ({
+    intent: {
+        pendingIntentEvent: undefined,
+        pendingBatchedIntentEvent: undefined,
+        isIntentModalOpen: false,
+        isBatchedIntentModalOpen: false,
+        intentResult: undefined,
+        intentError: undefined,
+    },
+
+    // === Intent URL handling ===
+
+    handleIntentUrl: async (url: string) => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+
+        if (!walletKit) {
+            throw new Error('WalletKit not initialized');
+        }
+
+        if (!(walletKit instanceof TonWalletKit)) {
+            throw new Error('Intent API requires TonWalletKit instance');
+        }
+
+        const activeWallet = state.getActiveWallet();
+        if (!activeWallet?.kitWalletId) {
+            throw new Error('No active wallet');
+        }
+
+        try {
+            log.info('Handling intent URL');
+            await walletKit.handleIntentUrl(url, activeWallet.kitWalletId);
+        } catch (error) {
+            log.error('Failed to handle intent URL:', error);
+            throw error;
+        }
+    },
+
+    isIntentUrl: (url: string): boolean => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+        if (!walletKit || !(walletKit instanceof TonWalletKit)) {
+            return false;
+        }
+        return walletKit.isIntentUrl(url);
+    },
+
+    // === Show intent request (called from listener) ===
+
+    showIntentRequest: (event: IntentRequestEvent) => {
+        set((state) => {
+            state.intent.pendingIntentEvent = event;
+            state.intent.isIntentModalOpen = true;
+            state.intent.intentResult = undefined;
+            state.intent.intentError = undefined;
+        });
+    },
+
+    showBatchedIntentRequest: (event: BatchedIntentEvent) => {
+        set((state) => {
+            state.intent.pendingBatchedIntentEvent = event;
+            state.intent.isBatchedIntentModalOpen = true;
+            state.intent.intentResult = undefined;
+            state.intent.intentError = undefined;
+        });
+    },
+
+    // === Approve / Reject ===
+
+    approveIntent: async (): Promise<void> => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+        const event = state.intent.pendingIntentEvent;
+
+        if (!walletKit || !(walletKit instanceof TonWalletKit)) {
+            throw new Error('WalletKit not initialized');
+        }
+        if (!event) {
+            log.error('No pending intent request to approve');
+            return;
+        }
+
+        const activeWallet = state.getActiveWallet();
+        if (!activeWallet?.kitWalletId) {
+            throw new Error('No active wallet');
+        }
+
+        try {
+            let result: IntentTransactionResponse | IntentSignDataResponse;
+
+            switch (event.type) {
+                case 'transaction':
+                    result = await walletKit.approveTransactionIntent(
+                        cloneEvent(event.value) as TransactionIntentRequestEvent,
+                        activeWallet.kitWalletId,
+                    );
+                    break;
+                case 'signData':
+                    result = await walletKit.approveSignDataIntent(
+                        cloneEvent(event.value) as SignDataIntentRequestEvent,
+                        activeWallet.kitWalletId,
+                    );
+                    break;
+                case 'action':
+                    result = await walletKit.approveActionIntent(
+                        cloneEvent(event.value) as ActionIntentRequestEvent,
+                        activeWallet.kitWalletId,
+                    );
+                    break;
+                default:
+                    throw new Error(`Unknown intent type: ${(event as IntentRequestEvent).type}`);
+            }
+
+            log.info('Intent approved successfully', { type: event.type });
+
+            set((state) => {
+                state.intent.intentResult = result;
+                state.intent.pendingIntentEvent = undefined;
+                state.intent.isIntentModalOpen = false;
+            });
+        } catch (error) {
+            log.error('Failed to approve intent:', error);
+            set((state) => {
+                state.intent.intentError = error instanceof Error ? error.message : 'Failed to approve intent';
+            });
+            throw error;
+        }
+    },
+
+    rejectIntent: async (reason?: string): Promise<void> => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+        const event = state.intent.pendingIntentEvent;
+
+        if (!walletKit || !(walletKit instanceof TonWalletKit)) {
+            throw new Error('WalletKit not initialized');
+        }
+        if (!event) {
+            log.error('No pending intent request to reject');
+            return;
+        }
+
+        try {
+            await walletKit.rejectIntent(cloneEvent(event), reason || 'User declined');
+            log.info('Intent rejected');
+
+            set((state) => {
+                state.intent.pendingIntentEvent = undefined;
+                state.intent.isIntentModalOpen = false;
+            });
+        } catch (error) {
+            log.error('Failed to reject intent:', error);
+        }
+    },
+
+    approveBatchedIntent: async (): Promise<void> => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+        const batch = state.intent.pendingBatchedIntentEvent;
+
+        if (!walletKit || !(walletKit instanceof TonWalletKit)) {
+            throw new Error('WalletKit not initialized');
+        }
+        if (!batch) {
+            log.error('No pending batched intent to approve');
+            return;
+        }
+
+        const activeWallet = state.getActiveWallet();
+        if (!activeWallet?.kitWalletId) {
+            throw new Error('No active wallet');
+        }
+
+        try {
+            const result = await walletKit.approveBatchedIntent(cloneEvent(batch), activeWallet.kitWalletId);
+            log.info('Batched intent approved successfully');
+
+            set((state) => {
+                state.intent.intentResult = result;
+                state.intent.pendingBatchedIntentEvent = undefined;
+                state.intent.isBatchedIntentModalOpen = false;
+            });
+        } catch (error) {
+            log.error('Failed to approve batched intent:', error);
+            set((state) => {
+                state.intent.intentError = error instanceof Error ? error.message : 'Failed to approve batched intent';
+            });
+            throw error;
+        }
+    },
+
+    rejectBatchedIntent: async (reason?: string): Promise<void> => {
+        const state = get();
+        const walletKit = state.walletCore.walletKit;
+        const batch = state.intent.pendingBatchedIntentEvent;
+
+        if (!walletKit || !(walletKit instanceof TonWalletKit)) {
+            throw new Error('WalletKit not initialized');
+        }
+        if (!batch) {
+            log.error('No pending batched intent to reject');
+            return;
+        }
+
+        try {
+            await walletKit.rejectIntent(cloneEvent(batch), reason || 'User declined');
+            log.info('Batched intent rejected');
+
+            set((state) => {
+                state.intent.pendingBatchedIntentEvent = undefined;
+                state.intent.isBatchedIntentModalOpen = false;
+            });
+        } catch (error) {
+            log.error('Failed to reject batched intent:', error);
+        }
+    },
+
+    closeIntentModal: () => {
+        set((state) => {
+            state.intent.pendingIntentEvent = undefined;
+            state.intent.isIntentModalOpen = false;
+        });
+    },
+
+    closeBatchedIntentModal: () => {
+        set((state) => {
+            state.intent.pendingBatchedIntentEvent = undefined;
+            state.intent.isBatchedIntentModalOpen = false;
+        });
+    },
+
+    // === Setup intent listeners (called from walletCoreSlice) ===
+
+    setupIntentListeners: (walletKit) => {
+        if (!(walletKit instanceof TonWalletKit)) {
+            log.warn('Intent listeners require TonWalletKit instance, skipping');
+            return;
+        }
+
+        walletKit.onIntentRequest((event) => {
+            log.info('Intent request received:', { type: 'type' in event ? event.type : 'batched' });
+
+            // Check if it's a batched event (has `intents` array)
+            if ('intents' in event) {
+                get().showBatchedIntentRequest(event as BatchedIntentEvent);
+            } else {
+                get().showIntentRequest(event as IntentRequestEvent);
+            }
+        });
+
+        log.info('Intent listeners initialized');
+    },
+});
diff --git a/demo/wallet-core/src/store/slices/walletCoreSlice.ts b/demo/wallet-core/src/store/slices/walletCoreSlice.ts
index 2b370f032..6ae747189 100644
--- a/demo/wallet-core/src/store/slices/walletCoreSlice.ts
+++ b/demo/wallet-core/src/store/slices/walletCoreSlice.ts
@@ -109,6 +109,7 @@ export const createWalletCoreSlice =
             try {
                 await walletKit.ensureInitialized();
                 get().setupTonConnectListeners(walletKit);
+                get().setupIntentListeners(walletKit);
 
                 set((state) => {
                     state.walletCore.walletKit = walletKit;
diff --git a/demo/wallet-core/src/types/store.ts b/demo/wallet-core/src/types/store.ts
index 6450382fd..aaeda0555 100644
--- a/demo/wallet-core/src/types/store.ts
+++ b/demo/wallet-core/src/types/store.ts
@@ -21,6 +21,10 @@ import type {
     WalletAdapter,
     SwapQuote,
     SwapToken,
+    IntentRequestEvent,
+    BatchedIntentEvent,
+    IntentTransactionResponse,
+    IntentSignDataResponse,
 } from '@ton/walletkit';
 
 import type {
@@ -233,12 +237,46 @@ export interface SwapSlice {
     validateSwapInputs: () => string | null;
 }
 
+// Intent slice - Intent URL handling and approval
+export interface IntentSlice {
+    intent: {
+        pendingIntentEvent?: IntentRequestEvent;
+        pendingBatchedIntentEvent?: BatchedIntentEvent;
+        isIntentModalOpen: boolean;
+        isBatchedIntentModalOpen: boolean;
+        intentResult?: IntentTransactionResponse | IntentSignDataResponse;
+        intentError?: string;
+    };
+
+    // Intent URL handling
+    handleIntentUrl: (url: string) => Promise<void>;
+    isIntentUrl: (url: string) => boolean;
+
+    // Show intent (called from listener)
+    showIntentRequest: (event: IntentRequestEvent) => void;
+    showBatchedIntentRequest: (event: BatchedIntentEvent) => void;
+
+    // Approve / Reject
+    approveIntent: () => Promise<void>;
+    rejectIntent: (reason?: string) => Promise<void>;
+    approveBatchedIntent: () => Promise<void>;
+    rejectBatchedIntent: (reason?: string) => Promise<void>;
+
+    // Modal controls
+    closeIntentModal: () => void;
+    closeBatchedIntentModal: () => void;
+
+    // Setup listeners
+    setupIntentListeners: (walletKit: ITonWalletKit) => void;
+}
+
 // Combined app state
 export interface AppState
     extends AuthSlice,
         WalletCoreSlice,
         WalletManagementSlice,
         TonConnectSlice,
+        IntentSlice,
         JettonsSlice,
         NftsSlice,
         SwapSlice {
@@ -265,6 +303,8 @@ export type NftsSliceCreator = StateCreator<AppState, [], [], NftsSlice>;
 
 export type SwapSliceCreator = StateCreator<AppState, [['zustand/immer', never]], [], SwapSlice>;
 
+export type IntentSliceCreator = StateCreator<AppState, [], [], IntentSlice>;
+
 // Migration types
 export interface MigrationState {
     version: number;
diff --git a/packages/walletkit/src/core/TonWalletKit.ts b/packages/walletkit/src/core/TonWalletKit.ts
index 5184d0d24..13200418f 100644
--- a/packages/walletkit/src/core/TonWalletKit.ts
+++ b/packages/walletkit/src/core/TonWalletKit.ts
@@ -598,8 +598,9 @@ export class TonWalletKit implements ITonWalletKit {
         const connectItems = batch.intents.filter((i) => i.type === 'connect');
         for (const item of connectItems) {
             if (item.type === 'connect') {
-                item.value.walletId = walletId;
-                await this.requestProcessor.approveConnectRequest(item.value, proof ? { proof } : undefined);
+                // Clone to avoid mutating frozen/immutable event objects (e.g. from Immer state)
+                const connectValue = { ...item.value, walletId };
+                await this.requestProcessor.approveConnectRequest(connectValue, proof ? { proof } : undefined);
             }
         }