diff --git a/frontend/components/voting/ReclaimVoteAction.test.tsx b/frontend/components/voting/ReclaimVoteAction.test.tsx
new file mode 100644
index 00000000..fe0a9684
--- /dev/null
+++ b/frontend/components/voting/ReclaimVoteAction.test.tsx
@@ -0,0 +1,150 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import ReclaimVoteAction from './ReclaimVoteAction';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import * as hooks from '@/hooks';
+import * as stacksLib from '@/lib/stacks';
+
+vi.mock('@/hooks', () => ({
+  useCurrentBlockHeight: vi.fn(),
+  useVote: vi.fn(),
+  useTransaction: vi.fn(),
+}));
+
+vi.mock('@/lib/stacks', () => ({
+  callReclaimVoteCost: vi.fn(),
+  invalidateStakeCache: vi.fn(),
+}));
+
+vi.mock('@/utils/formatSTX', () => ({
+  formatSTX: (amount: number) => (amount / 1000000).toString(),
+}));
+
+describe('ReclaimVoteAction', () => {
+  const mockProposal = {
+    id: 1,
+    title: 'Test Proposal',
+    proposer: 'ST1234',
+    amount: 1000,
+    description: 'Test',
+    votesFor: 0,
+    votesAgainst: 0,
+    executed: false,
+    createdAt: 100,
+    votingEndsAt: 200,
+    executionAllowedAt: 300,
+  };
+
+  const mockVote = {
+    proposalId: 1,
+    voter: 'ST1234',
+    support: true,
+    weight: 100,
+    costPaid: 10000000, // 10 STX
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders null if user Address is not provided', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    const { container } = render(<ReclaimVoteAction proposal={mockProposal} />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('renders null if vote is null or costPaid is 0', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: null, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    const { container } = render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('shows loading skeleton when vote data is loading', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: null, loading: true, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    const { container } = render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    expect(container.querySelector('.animate-pulse')).toBeTruthy();
+  });
+
+  it('shows locked message if voting is still active', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 150, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    
+    expect(screen.getByText(/You have 10 STX currently locked/i)).toBeTruthy();
+    const button = screen.getByRole('button', { name: /Reclaim 10 STX/i }) as HTMLButtonElement;
+    expect(button.disabled).toBe(true);
+  });
+
+  it('shows available message and enables button if voting has ended', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    
+    expect(screen.getByText(/The voting period has ended/i)).toBeTruthy();
+    expect(screen.getAllByText(/Available/i).length).toBeGreaterThan(0);
+    
+    const button = screen.getByRole('button', { name: /Reclaim 10 STX/i }) as HTMLButtonElement;
+    expect(button.disabled).toBe(false);
+  });
+
+  it('calls execute function when button is clicked', async () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    
+    const mockExecute = vi.fn().mockImplementation((cb) => cb());
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: mockExecute, isLoading: false, isError: false, isSuccess: false, isIdle: true, error: null, reset: vi.fn() });
+
+    render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    
+    const button = screen.getByRole('button', { name: /Reclaim 10 STX/i });
+    fireEvent.click(button);
+
+    expect(mockExecute).toHaveBeenCalled();
+  });
+
+  it('shows success message and explorer link when transaction is successful', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ 
+      execute: vi.fn(), 
+      isLoading: false, 
+      isError: false, 
+      isSuccess: true, 
+      isIdle: false, 
+      txId: '0x123',
+      error: null, 
+      reset: vi.fn() 
+    });
+
+    render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    
+    expect(screen.getByText(/Stake reclaimed successfully/i)).toBeTruthy();
+    const link = screen.getByRole('link', { name: /View Transaction/i });
+    expect(link).toBeTruthy();
+    expect(link.getAttribute('href')).toContain('0x123');
+  });
+
+  it('shows loading state when transaction is executing', () => {
+    vi.mocked(hooks.useCurrentBlockHeight).mockReturnValue({ blockHeight: 250, error: null, isLoading: false, refresh: vi.fn() });
+    vi.mocked(hooks.useVote).mockReturnValue({ vote: mockVote, loading: false, error: null, refresh: vi.fn() });
+    vi.mocked(hooks.useTransaction).mockReturnValue({ execute: vi.fn(), isLoading: true, isError: false, isSuccess: false, isIdle: false, error: null, reset: vi.fn() });
+
+    render(<ReclaimVoteAction proposal={mockProposal} userAddress="ST1234" />);
+    
+    expect(screen.getByText(/Reclaiming STX.../i)).toBeTruthy();
+    const button = screen.getByRole('button') as HTMLButtonElement;
+    expect(button.disabled).toBe(true);
+  });
+});
diff --git a/frontend/components/voting/ReclaimVoteAction.tsx b/frontend/components/voting/ReclaimVoteAction.tsx
new file mode 100644
index 00000000..6b9e04e4
--- /dev/null
+++ b/frontend/components/voting/ReclaimVoteAction.tsx
@@ -0,0 +1,207 @@
+'use client';
+
+import React from 'react';
+import { Proposal } from '@/types';
+import { useCurrentBlockHeight, useVote, useTransaction } from '@/hooks';
+import { callReclaimVoteCost, invalidateStakeCache } from '@/lib/stacks';
+import { formatSTX } from '@/utils/formatSTX';
+import { Coins, Lock, CheckCircle, AlertCircle, RefreshCw, ExternalLink } from 'lucide-react';
+
+/**
+ * Props for the ReclaimVoteAction component.
+ */
+interface ReclaimVoteActionProps {
+  /** The proposal object containing metadata like title and voting period */
+  proposal: Proposal;
+  /** The Stacks address of the current user */
+  userAddress?: string;
+  /** Optional callback triggered after a successful reclaim transaction */
+  onSuccess?: () => void;
+}
+
+/**
+ * Premium action component for reclaiming vote costs.
+ * 
+ * This component provides a guided user interface for recovering the STX cost 
+ * paid during quadratic voting. It automatically determines eligibility based 
+ * on current block height and individual voting records.
+ * 
+ * @param props The component props
+ */
+export default function ReclaimVoteAction({ 
+  proposal, 
+  userAddress,
+  onSuccess 
+}: ReclaimVoteActionProps) {
+  const { blockHeight } = useCurrentBlockHeight();
+  const { vote, loading: isVoteLoading, refresh: refreshVote } = useVote(proposal.id, userAddress);
+  const { 
+    execute, 
+    isLoading: isReclaiming, 
+    isSuccess,
+    txId,
+    error,
+    reset: resetTransaction
+  } = useTransaction({
+    type: 'reclaim-vote',
+    proposalId: proposal.id,
+    title: proposal.title,
+    onSuccess: (txId) => {
+      refreshVote();
+      if (userAddress) {
+        invalidateStakeCache(userAddress);
+      }
+      onSuccess?.();
+    }
+  });
+
+  // Calculate if voting has ended based on block height
+  const isVotingActive = blockHeight ? blockHeight <= proposal.votingEndsAt : true;
+  
+  // A user can reclaim if voting ended, they voted, and there is a cost to reclaim
+  const canReclaim = !isVotingActive && vote && vote.costPaid > 0;
+
+  // Render a loading state if vote data is pending
+  if (userAddress && isVoteLoading) {
+    return (
+      <div className="mt-6 rounded-2xl bg-slate-900/50 border border-slate-800 p-6 backdrop-blur-sm shadow-xl animate-pulse">
+        <div className="flex items-start gap-5">
+          <div className="h-12 w-12 rounded-xl bg-slate-800" />
+          <div className="flex-1 space-y-3">
+            <div className="h-4 w-1/3 rounded bg-slate-800" />
+            <div className="h-4 w-full rounded bg-slate-800" />
+            <div className="h-10 w-full rounded bg-slate-800" />
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  // Don't render if user hasn't voted or there's nothing to reclaim
+  if (!userAddress || !vote || vote.costPaid === 0) {
+    return null;
+  }
+
+  const handleReclaim = async () => {
+    try {
+      await execute(() => new Promise((resolve, reject) => {
+        callReclaimVoteCost(proposal.id, {
+          onFinish: (txId) => resolve(txId),
+          onCancel: () => reject(new Error('Transaction cancelled'))
+        });
+      }));
+    } catch (err) {
+      console.error('[SprintFund] Reclaim failed:', err);
+    }
+  };
+
+  return (
+    <div className="mt-6 rounded-2xl bg-slate-900/50 border border-slate-800 p-6 backdrop-blur-sm shadow-xl transition-all hover:border-slate-700">
+      <div className="flex items-start gap-5">
+        <div className={`flex h-12 w-12 items-center justify-center rounded-xl shadow-lg ${
+          isVotingActive 
+            ? 'bg-amber-500/10 text-amber-400 border border-amber-500/20' 
+            : 'bg-green-500/10 text-green-400 border border-green-500/20'
+        }`}>
+          {isVotingActive ? (
+            <Lock className="h-6 w-6" />
+          ) : (
+            <Coins className="h-6 w-6" />
+          )}
+        </div>
+
+        <div className="flex-1">
+          <div className="flex items-center justify-between mb-2">
+            <h4 className="text-lg font-bold text-white tracking-tight">
+              Vote Cost Recovery
+            </h4>
+            {!isVotingActive && (
+              <span className="flex items-center gap-1.5 rounded-full bg-green-500/10 px-2.5 py-1 text-[10px] font-black uppercase tracking-widest text-green-400 border border-green-500/20">
+                <CheckCircle className="h-3 w-3" />
+                Available
+              </span>
+            )}
+          </div>
+          
+          <p className="text-sm text-slate-400 leading-relaxed mb-4">
+            {isVotingActive 
+              ? `You have ${formatSTX(vote.costPaid)} STX currently locked by this vote. You can reclaim it once the voting period ends.`
+              : `The voting period has ended. You can now reclaim your ${formatSTX(vote.costPaid)} STX to make it available for future votes or withdrawal.`
+            }
+          </p>
+
+          <button
+            onClick={handleReclaim}
+            disabled={!canReclaim || isReclaiming}
+            className={`group relative flex w-full items-center justify-center gap-2 rounded-xl px-4 py-3 text-sm font-bold transition-all ${
+              canReclaim && !isReclaiming
+                ? 'bg-indigo-600 text-white shadow-[0_0_20px_rgba(79,70,229,0.3)] hover:bg-indigo-500 hover:-translate-y-0.5 active:translate-y-0'
+                : 'bg-slate-800 text-slate-500 cursor-not-allowed border border-slate-700'
+            }`}
+          >
+            {isReclaiming ? (
+              <>
+                <RefreshCw className="h-4 w-4 animate-spin" />
+                Reclaiming STX...
+              </>
+            ) : (
+              <>
+                <Coins className="h-4 w-4 transition-transform group-hover:rotate-12" />
+                Reclaim {formatSTX(vote.costPaid)} STX
+              </>
+            )}
+          </button>
+          
+          <div className="mt-4 flex items-start gap-3 rounded-lg bg-indigo-500/5 p-3 border border-indigo-500/10">
+            <AlertCircle className="h-4 w-4 text-indigo-400 shrink-0 mt-0.5" />
+            <p className="text-[11px] text-indigo-200/70 font-medium italic leading-normal">
+              Note: Reclaiming vote cost does not remove your vote from the proposal tally. It simply releases the locked stake portion used for quadratic weight.
+            </p>
+          </div>
+        </div>
+      </div>
+      
+      {isSuccess && (
+        <div className="mt-4 rounded-xl bg-green-500/10 border border-green-500/20 p-4 animate-in fade-in slide-in-from-top-2 duration-500">
+          <div className="flex items-center gap-3">
+            <CheckCircle className="h-5 w-5 text-green-400" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-green-100">
+                Stake reclaimed successfully! Your available balance has been updated.
+              </p>
+              {txId && (
+                <a 
+                  href={`https://explorer.hiro.so/txid/${txId}?chain=mainnet`}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="mt-1 flex items-center gap-1 text-xs text-green-400 underline hover:text-green-300 font-bold"
+                >
+                  View Transaction <ExternalLink className="h-3 w-3" />
+                </a>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+
+      {error && (
+        <div className="mt-4 rounded-xl bg-red-500/10 border border-red-500/20 p-4 animate-in fade-in slide-in-from-top-2 duration-500">
+          <div className="flex items-center gap-3">
+            <AlertCircle className="h-5 w-5 text-red-400" />
+            <div className="flex-1">
+              <p className="text-sm font-medium text-red-100">
+                Recovery failed: {error.message}
+              </p>
+              <button 
+                onClick={resetTransaction}
+                className="mt-1 text-xs text-red-400 underline hover:text-red-300 font-bold"
+              >
+                Dismiss
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/components/voting/index.ts b/frontend/components/voting/index.ts
index 1d1e9a68..2fb55a02 100644
--- a/frontend/components/voting/index.ts
+++ b/frontend/components/voting/index.ts
@@ -13,6 +13,7 @@ export { default as DelegatorCard } from '../DelegatorCard';
 export { default as DelegatorMarketplace } from '../DelegatorMarketplace';
 export { default as BulkVotingQueue } from '../BulkVotingQueue';
 export { default as DelegationStats } from '../DelegationStats';
+export { default as ReclaimVoteAction } from './ReclaimVoteAction';
 
 // Analytics and visualization
 export { default as VotingAnalyticsDashboard } from '../VotingAnalyticsDashboard';
diff --git a/frontend/src/app/proposals/[id]/page.tsx b/frontend/src/app/proposals/[id]/page.tsx
index f432cf32..fc2e64ca 100644
--- a/frontend/src/app/proposals/[id]/page.tsx
+++ b/frontend/src/app/proposals/[id]/page.tsx
@@ -13,6 +13,8 @@ import { proposalExecutionService, type ExecutionHistoryEntry } from '@/services
 import { ProposalCountdown } from '@/components/ProposalCountdown';
 import { formatBlockHeight } from '@/lib/block-height';
 import type { Proposal } from '@/types';
+import { useConnect } from '@stacks/connect-react';
+import ReclaimVoteAction from '@/components/voting/ReclaimVoteAction';
 
 export default function ProposalDetailPage() {
   const params = useParams();
@@ -21,6 +23,11 @@ export default function ProposalDetailPage() {
   const [relatedProposals, setRelatedProposals] = useState<Proposal[]>([]);
   const [executionStatus, setExecutionStatus] = useState<ExecutionHistoryEntry | null>(null);
   const [loading, setLoading] = useState(true);
+  
+  const { userSession } = useConnect();
+  const userAddress = userSession?.isUserSignedIn() 
+    ? userSession.loadUserData().profile?.stxAddress?.mainnet 
+    : undefined;
 
   useEffect(() => {
     const fetchProposalData = async () => {
@@ -163,6 +170,13 @@ export default function ProposalDetailPage() {
               />
             )}
 
+            {proposal && userAddress && (
+              <ReclaimVoteAction 
+                proposal={proposal} 
+                userAddress={userAddress} 
+              />
+            )}
+
             <VotingHistory votes={[]} />
 
             <ProposalDiscussionSection proposalId={proposalId} />
diff --git a/frontend/src/hooks/index.ts b/frontend/src/hooks/index.ts
index a40d2076..9b0d4a54 100644
--- a/frontend/src/hooks/index.ts
+++ b/frontend/src/hooks/index.ts
@@ -11,3 +11,4 @@ export { useStxPriceData } from './useStxPrice';
 export { useWalletBalanceData } from './useWalletBalance';
 // Blockchain state hooks
 export { useCurrentBlockHeight } from './useCurrentBlockHeight';
+export { useVote } from './useVote';
diff --git a/frontend/src/hooks/useVote.test.ts b/frontend/src/hooks/useVote.test.ts
new file mode 100644
index 00000000..14d3ffa0
--- /dev/null
+++ b/frontend/src/hooks/useVote.test.ts
@@ -0,0 +1,81 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { useVote } from './useVote';
+import * as stacksLib from '@/lib/stacks';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+
+vi.mock('@/lib/stacks', () => ({
+  getVote: vi.fn(),
+}));
+
+describe('useVote', () => {
+  const mockVote = {
+    proposalId: 1,
+    voter: 'ST1234',
+    support: true,
+    weight: 100,
+    costPaid: 10,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return null when voterAddress is missing', async () => {
+    const { result } = renderHook(() => useVote(1, undefined));
+
+    expect(result.current.loading).toBe(false);
+    expect(result.current.vote).toBeNull();
+    expect(stacksLib.getVote).not.toHaveBeenCalled();
+  });
+
+  it('should fetch and return vote data', async () => {
+    vi.mocked(stacksLib.getVote).mockResolvedValueOnce(mockVote);
+
+    const { result } = renderHook(() => useVote(1, 'ST1234'));
+
+    expect(result.current.loading).toBe(true);
+    
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.vote).toEqual(mockVote);
+    expect(result.current.error).toBeNull();
+    expect(stacksLib.getVote).toHaveBeenCalledWith(1, 'ST1234');
+  });
+
+  it('should handle errors from getVote', async () => {
+    vi.mocked(stacksLib.getVote).mockRejectedValueOnce(new Error('Network error'));
+
+    const { result } = renderHook(() => useVote(1, 'ST1234'));
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.vote).toBeNull();
+    expect(result.current.error).toEqual(new Error('Network error'));
+  });
+
+  it('should allow manual refresh', async () => {
+    vi.mocked(stacksLib.getVote)
+      .mockResolvedValueOnce(mockVote)
+      .mockResolvedValueOnce({ ...mockVote, costPaid: 0 });
+
+    const { result } = renderHook(() => useVote(1, 'ST1234'));
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.vote?.costPaid).toBe(10);
+
+    result.current.refresh();
+
+    await waitFor(() => {
+      expect(result.current.vote?.costPaid).toBe(0);
+    });
+
+    expect(stacksLib.getVote).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/frontend/src/hooks/useVote.ts b/frontend/src/hooks/useVote.ts
new file mode 100644
index 00000000..4f2586ef
--- /dev/null
+++ b/frontend/src/hooks/useVote.ts
@@ -0,0 +1,42 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getVote } from '@/lib/stacks';
+import type { VoteRecord } from '@/types';
+
+/**
+ * Custom hook to fetch and track a specific user's voting record for a proposal.
+ * This is essential for managing the lifecycle of quadratic voting costs and 
+ * verifying reclaim eligibility once a voting period has expired.
+ * 
+ * @param proposalId The unique identifier of the proposal
+ * @param voterAddress The Stacks address of the voter (optional)
+ * @returns Object containing the vote record, loading state, error, and refresh function
+ */
+export function useVote(proposalId: number, voterAddress?: string) {
+  const [vote, setVote] = useState<VoteRecord | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchVote = useCallback(async () => {
+    if (!voterAddress) {
+      setVote(null);
+      return;
+    }
+
+    try {
+      setLoading(true);
+      setError(null);
+      const data = await getVote(proposalId, voterAddress);
+      setVote(data);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error('Failed to fetch vote'));
+    } finally {
+      setLoading(false);
+    }
+  }, [proposalId, voterAddress]);
+
+  useEffect(() => {
+    fetchVote();
+  }, [fetchVote]);
+
+  return { vote, loading, error, refresh: fetchVote };
+}
diff --git a/frontend/src/lib/blockchain-cache.ts b/frontend/src/lib/blockchain-cache.ts
index ad664f85..11766c93 100644
--- a/frontend/src/lib/blockchain-cache.ts
+++ b/frontend/src/lib/blockchain-cache.ts
@@ -1,4 +1,4 @@
-import type { Proposal, ProposalPage } from '../types';
+import type { Proposal, ProposalPage, VoteRecord } from '../types';
 
 interface CacheEntry<T> {
   data: T;
@@ -19,6 +19,7 @@ class BlockchainDataCache {
   private proposalCounts = new Map<string, CacheEntry<number>>();
   private stakes = new Map<string, CacheEntry<number>>();
   private minStakeAmounts = new Map<string, CacheEntry<number>>();
+  private votes = new Map<string, CacheEntry<VoteRecord>>();
 
   private stats: CacheStats = {
     hits: 0,
@@ -96,6 +97,16 @@ class BlockchainDataCache {
   getMinStakeAmount(): number | null {
     return this.getCachedEntry(this.minStakeAmounts.get('global'));
   }
+  
+  setVote(proposalId: number, voter: string, vote: VoteRecord, ttl: number = this.DEFAULT_TTL_MS): void {
+    const key = `${proposalId}-${voter}`;
+    this.votes.set(key, { data: vote, timestamp: Date.now(), ttl });
+  }
+
+  getVote(proposalId: number, voter: string): VoteRecord | null {
+    const key = `${proposalId}-${voter}`;
+    return this.getCachedEntry(this.votes.get(key));
+  }
 
   private getCachedEntry<T>(entry: CacheEntry<T> | undefined): T | null {
     if (!entry) {
@@ -129,12 +140,24 @@ class BlockchainDataCache {
     this.stakes.delete(address);
   }
 
+  /**
+   * Invalidate a specific voting record in the cache.
+   * Forces a refresh from the blockchain on the next fetch attempt.
+   * 
+   * @param proposalId The ID of the proposal
+   * @param voter The Stacks address of the voter
+   */
+  invalidateVote(proposalId: number, voter: string): void {
+    this.votes.delete(`${proposalId}-${voter}`);
+  }
+
   invalidateAll(): void {
     this.proposals.clear();
     this.proposalPages.clear();
     this.proposalCounts.clear();
     this.stakes.clear();
     this.minStakeAmounts.clear();
+    this.votes.clear();
   }
 
   getStats(): CacheStats {
@@ -163,7 +186,8 @@ class BlockchainDataCache {
       this.proposalPages.size +
       this.proposalCounts.size +
       this.stakes.size +
-      this.minStakeAmounts.size
+      this.minStakeAmounts.size +
+      this.votes.size
     );
   }
 
diff --git a/frontend/src/lib/stacks.ts b/frontend/src/lib/stacks.ts
index c8aea3fb..264b6cac 100644
--- a/frontend/src/lib/stacks.ts
+++ b/frontend/src/lib/stacks.ts
@@ -11,7 +11,7 @@ import { CONTRACT_ADDRESS, CONTRACT_NAME, CONTRACT_PRINCIPAL, NETWORK } from '..
 import { sanitizeText, sanitizeMultilineText } from './sanitize';
 import { blockchainCache } from './blockchain-cache';
 import { AsyncError, ErrorCode } from './async-errors';
-import type { Proposal, ProposalPage } from '../types';
+import type { Proposal, ProposalPage, StakeInfo, VoteRecord } from '../types';
 import type {
   ProposalCountResponse,
   ProposalResponse,
@@ -20,6 +20,7 @@ import type {
   TxCallbacks,
   RawProposal,
   RawStake,
+  RawVote,
 } from '../types/contract';
 import {
   validateRawProposal,
@@ -422,6 +423,52 @@ export function callExecuteProposal(proposalId: number, cb: TxCallbacks): void {
   });
 }
 
+/**
+ * Submit a transaction to reclaim the STX cost paid during quadratic voting.
+ * This is only allowed after the voting period for the specified proposal has ended.
+ * 
+ * @param proposalId The ID of the proposal to recover costs from
+ * @param cb Object containing onFinish (txId) and onCancel callbacks
+ */
+export function callReclaimVoteCost(proposalId: number, cb: TxCallbacks): void {
+  contractCall({
+    functionName: 'reclaim-vote-cost',
+    functionArgs: [uintCV(proposalId)],
+    cb,
+  });
+}
+
+/**
+ * Fetch a specific user's vote on a proposal.
+ * @param proposalId ID of the proposal
+ * @param voter Principal of the voter
+ * @returns VoteRecord or null if no vote was found
+ */
+export async function getVote(proposalId: number, voter: string): Promise<VoteRecord | null> {
+  try {
+    const cached = blockchainCache.getVote(proposalId, voter);
+    if (cached !== null) {
+      return cached;
+    }
+
+    const raw = await readOnly<RawVote>('get-vote', [
+      uintCV(proposalId),
+      principalCV(voter),
+    ]);
+
+    if (!raw) {
+      return null;
+    }
+
+    const vote = convertRawToVote(proposalId, voter, raw);
+    blockchainCache.setVote(proposalId, voter, vote);
+    return vote;
+  } catch (err) {
+    console.error(`[SprintFund] Failed to fetch vote for prop ${proposalId}:`, err);
+    return null;
+  }
+}
+
 export function invalidateProposalCache(proposalId: number): void {
   blockchainCache.invalidateProposal(proposalId);
 }
@@ -438,6 +485,10 @@ export function invalidateStakeCache(address: string): void {
   blockchainCache.invalidateStake(address);
 }
 
+export function invalidateVoteCache(proposalId: number, voter: string): void {
+  blockchainCache.invalidateVote(proposalId, voter);
+}
+
 export function invalidateAllBlockchainCache(): void {
   blockchainCache.invalidateAll();
 }
diff --git a/frontend/src/lib/type-converters.ts b/frontend/src/lib/type-converters.ts
index f6f615ee..f1cda2d1 100644
--- a/frontend/src/lib/type-converters.ts
+++ b/frontend/src/lib/type-converters.ts
@@ -60,6 +60,7 @@ export function convertRawToVote(proposalId: number, voter: string, raw: RawVote
     voter,
     support: unwrapClarityValue(raw.support) ?? false,
     weight: unwrapClarityValue(raw.weight) ?? 0,
+    costPaid: unwrapClarityValue(raw['cost-paid']) ?? 0,
   };
 }
 
diff --git a/frontend/src/types/contract.ts b/frontend/src/types/contract.ts
index 7036ad75..e3bca567 100644
--- a/frontend/src/types/contract.ts
+++ b/frontend/src/types/contract.ts
@@ -54,6 +54,7 @@ export interface RawProposal {
  */
 export interface RawStake {
   amount: ClarityValue<number>;
+  'locked-until': ClarityValue<number>;
 }
 
 /**
@@ -64,6 +65,7 @@ export interface RawStake {
 export interface RawVote {
   weight: ClarityValue<number>;
   support: ClarityValue<boolean>;
+  'cost-paid': ClarityValue<number>;
 }
 
 /* ═══════════════════════════════════════════════
@@ -141,6 +143,9 @@ export const CONTRACT_ERROR_CODES = {
   110: 'ERR-ZERO-AMOUNT',
   111: 'ERR-INSUFFICIENT-BALANCE',
   112: 'ERR-PROPOSAL-EXPIRED',
+  113: 'ERR-PROPOSAL-CANCELLED',
+  114: 'ERR-STAKE-LOCKED',
+  115: 'ERR-TIMELOCK-ACTIVE',
 } as const;
 
 export type ContractErrorCode = keyof typeof CONTRACT_ERROR_CODES;
diff --git a/frontend/src/types/transaction.ts b/frontend/src/types/transaction.ts
index 08bba748..c66bc3b4 100644
--- a/frontend/src/types/transaction.ts
+++ b/frontend/src/types/transaction.ts
@@ -1,4 +1,4 @@
-export type TransactionType = 'stake' | 'vote' | 'create-proposal' | 'execute' | 'unstake';
+export type TransactionType = 'stake' | 'vote' | 'create-proposal' | 'execute' | 'unstake' | 'reclaim-vote';
 
 export type TransactionStatus = 'pending' | 'confirmed' | 'failed' | 'dropped';
 
diff --git a/frontend/src/types/voting.ts b/frontend/src/types/voting.ts
index 940cedc1..c8cfeaec 100644
--- a/frontend/src/types/voting.ts
+++ b/frontend/src/types/voting.ts
@@ -19,6 +19,7 @@ export interface VoteRecord {
   voter: string;
   support: boolean;
   weight: number;
+  costPaid: number;
 }
 
 /**
diff --git a/frontend/vitest.config.ts b/frontend/vitest.config.ts
index c9f70ffa..8ed1b936 100644
--- a/frontend/vitest.config.ts
+++ b/frontend/vitest.config.ts
@@ -22,7 +22,7 @@ export default defineConfig({
   plugins: [react()],
   test: {
     environment: 'jsdom',
-    include: ['src/**/*.test.{ts,tsx}'],
+    include: ['src/**/*.test.{ts,tsx}', 'components/**/*.test.{ts,tsx}', 'utils/**/*.test.{ts,tsx}'],
     exclude: ['node_modules/**'],
     setupFiles: [resolve(configDir, 'src/test/vitest.setup.ts')],
     globals: true,