diff --git a/src/components/common/WalletActivityFeed.tsx b/src/components/common/WalletActivityFeed.tsx
new file mode 100644
index 0000000..32e41fa
--- /dev/null
+++ b/src/components/common/WalletActivityFeed.tsx
@@ -0,0 +1,80 @@
+import { useMemo } from 'react';
+import TransactionHistory, {
+	type Transaction,
+} from '@/components/common/TransactionHistory';
+import { useWalletActivity } from '@/hooks/useWallet';
+import { useInfiniteScroll } from '@/hooks/useInfiniteScroll';
+import type { WalletActivityTrade } from '@/services/walletActivity.service';
+
+interface WalletActivityFeedProps {
+	/** Connected wallet address used as the cache key for the activity query. */
+	address: string;
+}
+
+function toTransaction(entry: WalletActivityTrade): Transaction {
+	return {
+		id: entry.id,
+		type: entry.type,
+		creatorId: entry.creatorId,
+		creatorHandle: entry.creatorHandle,
+		amount: entry.amount,
+		price: entry.price,
+		timestamp: entry.timestamp,
+		txHash: entry.txHash,
+		status: entry.status,
+	};
+}
+
+const WalletActivityFeed: React.FC<WalletActivityFeedProps> = ({ address }) => {
+	const {
+		data,
+		fetchNextPage,
+		hasNextPage,
+		isFetchingNextPage,
+		isLoading,
+	} = useWalletActivity(address);
+
+	// Collapse the paginated `pages` array into a single flat list of
+	// transactions. Deduplicate by `id` so overlapping pages (e.g. when the
+	// backend paginates by timestamp boundary) don't render the same trade
+	// twice. Accepted criteria #4: "No duplicate trades in the combined list".
+	const transactions = useMemo(() => {
+		const seen = new Set<string>();
+		const result: Transaction[] = [];
+		for (const page of data?.pages ?? []) {
+			for (const trade of page.trades) {
+				if (seen.has(trade.id)) continue;
+				seen.add(trade.id);
+				result.push(toTransaction(trade));
+			}
+		}
+		return result;
+	}, [data]);
+
+	// `useWalletActivity` already gates its own fetch on `!!address`, so
+	// `hasNextPage` cannot become true without one — only the loading
+	// flags matter here for re-entrancy.
+	const sentinelRef = useInfiniteScroll<HTMLDivElement>({
+		enabled: !isFetchingNextPage && !isLoading,
+		hasMore: !!hasNextPage,
+		onLoadMore: () => {
+			void fetchNextPage();
+		},
+	});
+
+	return (
+		<>
+			<TransactionHistory transactions={transactions} />
+			{hasNextPage && (
+				<div
+					ref={sentinelRef}
+					data-testid="activity-feed-sentinel"
+					aria-hidden="true"
+					className="h-px w-full"
+				/>
+			)}
+		</>
+	);
+};
+
+export default WalletActivityFeed;
diff --git a/src/components/common/__tests__/WalletActivityFeed.infiniteScroll.integration.test.tsx b/src/components/common/__tests__/WalletActivityFeed.infiniteScroll.integration.test.tsx
new file mode 100644
index 0000000..bbfe21d
--- /dev/null
+++ b/src/components/common/__tests__/WalletActivityFeed.infiniteScroll.integration.test.tsx
@@ -0,0 +1,350 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import React from 'react';
+
+import WalletActivityFeed from '@/components/common/WalletActivityFeed';
+import * as walletActivityService from '@/services/walletActivity.service';
+import type { WalletActivityTrade } from '@/services/walletActivity.service';
+
+const WALLET_ADDRESS = 'GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5';
+
+// jsdom does not implement IntersectionObserver — install a recording mock
+// that captures the callback the hook registers so the test can drive it
+// deterministically without relying on real viewport geometry.
+interface CapturedObserver {
+	callback: IntersectionObserverCallback;
+	observe: ReturnType<typeof vi.fn>;
+	disconnect: ReturnType<typeof vi.fn>;
+	unobserve: ReturnType<typeof vi.fn>;
+}
+
+const observers: CapturedObserver[] = [];
+
+class MockIntersectionObserver {
+	callback: IntersectionObserverCallback;
+	observe = vi.fn();
+	disconnect = vi.fn();
+	unobserve = vi.fn();
+	constructor(cb: IntersectionObserverCallback) {
+		this.callback = cb;
+		observers.push({
+			callback: cb,
+			observe: this.observe,
+			disconnect: this.disconnect,
+			unobserve: this.unobserve,
+		});
+	}
+}
+
+const page1Trades: WalletActivityTrade[] = [
+	{
+		id: 'A',
+		type: 'buy',
+		creatorId: '1',
+		creatorHandle: 'arivers',
+		amount: 2,
+		price: 0.05,
+		timestamp: Date.now() - 1000 * 60 * 5,
+		txHash: '0xaaaa...0011',
+		status: 'completed',
+	},
+	{
+		id: 'B',
+		type: 'sell',
+		creatorId: '2',
+		creatorHandle: 'schen_dev',
+		amount: 1,
+		price: 0.12,
+		timestamp: Date.now() - 1000 * 60 * 45,
+		txHash: '0xbbbb...0022',
+		status: 'completed',
+	},
+	{
+		id: 'C',
+		type: 'buy',
+		creatorId: '3',
+		creatorHandle: 'mthorne',
+		amount: 4,
+		price: 0.08,
+		timestamp: Date.now() - 1000 * 60 * 90,
+		txHash: '0xcccc...0033',
+		status: 'completed',
+	},
+];
+
+const page2Trades: WalletActivityTrade[] = [
+	{
+		id: 'D',
+		type: 'buy',
+		creatorId: '4',
+		creatorHandle: 'evance_design',
+		amount: 3,
+		price: 0.04,
+		timestamp: Date.now() - 1000 * 60 * 60 * 2,
+		txHash: '0xdddd...0044',
+		status: 'completed',
+	},
+	{
+		id: 'E',
+		type: 'sell',
+		creatorId: '5',
+		creatorHandle: 'dkojo_beats',
+		amount: 2,
+		price: 0.15,
+		timestamp: Date.now() - 1000 * 60 * 60 * 4,
+		txHash: '0xeeee...0055',
+		status: 'completed',
+	},
+	{
+		id: 'F',
+		type: 'buy',
+		creatorId: '6',
+		creatorHandle: 'yuki_s',
+		amount: 6,
+		price: 0.07,
+		timestamp: Date.now() - 1000 * 60 * 60 * 8,
+		txHash: '0xffff...0066',
+		status: 'completed',
+	},
+];
+
+const setupFetchMock = () =>
+	vi
+		.spyOn(walletActivityService, 'fetchWalletActivityPage')
+		.mockResolvedValueOnce({ trades: page1Trades, nextPage: 2 })
+		.mockResolvedValueOnce({ trades: page2Trades, nextPage: null });
+
+const renderFeed = () => {
+	const queryClient = new QueryClient({
+		defaultOptions: {
+			queries: {
+				retry: false,
+				gcTime: 0,
+			},
+		},
+	});
+	const wrapper = ({ children }: { children: React.ReactNode }) => (
+		<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+	);
+	const utils = render(<WalletActivityFeed address={WALLET_ADDRESS} />, {
+		wrapper,
+	});
+	return { ...utils, queryClient };
+};
+
+const simulateIntersection = (isIntersecting: boolean) => {
+	const obs = observers[observers.length - 1];
+	if (!obs) throw new Error('No IntersectionObserver registered yet');
+	act(() => {
+		obs.callback(
+			[{ isIntersecting } as IntersectionObserverEntry],
+			{} as IntersectionObserver
+		);
+	});
+};
+
+describe('WalletActivityFeed infinite scroll integration (#677)', () => {
+	beforeEach(() => {
+		observers.length = 0;
+		vi.stubGlobal('IntersectionObserver', MockIntersectionObserver);
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		vi.unstubAllGlobals();
+	});
+
+	// Acceptance #1: page 1 trades visible on initial load
+	it('renders page 1 trades on initial load', async () => {
+		const fetchSpy = setupFetchMock();
+
+		renderFeed();
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-A')
+			).toBeInTheDocument();
+		});
+
+		expect(
+			screen.getByTestId('activity-creator-handle-A')
+		).toHaveTextContent('@arivers');
+		expect(
+			screen.getByTestId('activity-creator-handle-B')
+		).toHaveTextContent('@schen_dev');
+		expect(
+			screen.getByTestId('activity-creator-handle-C')
+		).toHaveTextContent('@mthorne');
+
+		// Page 2 trades must not be visible yet
+		expect(
+			screen.queryByTestId('activity-creator-handle-D')
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('activity-creator-handle-E')
+		).not.toBeInTheDocument();
+		expect(
+			screen.queryByTestId('activity-creator-handle-F')
+		).not.toBeInTheDocument();
+
+		// Only page 1 was fetched
+		expect(fetchSpy).toHaveBeenCalledTimes(1);
+		expect(fetchSpy).toHaveBeenCalledWith(WALLET_ADDRESS, 1);
+	});
+
+	// Acceptance #2: scroll triggers next page fetch
+	it('fetches the next page when the sentinel scrolls into view', async () => {
+		const fetchSpy = setupFetchMock();
+
+		renderFeed();
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-A')
+			).toBeInTheDocument();
+		});
+
+		// The sentinel should have observed itself and registered an observer
+		await waitFor(() => {
+			expect(observers.length).toBeGreaterThan(0);
+		});
+
+		simulateIntersection(true);
+
+		await waitFor(() => {
+			expect(fetchSpy).toHaveBeenCalledTimes(2);
+		});
+
+		expect(fetchSpy).toHaveBeenNthCalledWith(2, WALLET_ADDRESS, 2);
+	});
+
+	// Acceptance #3: page 2 trades appended below page 1 trades
+	it('appends page 2 trades below page 1 trades after fetching', async () => {
+		setupFetchMock();
+
+		const { container } = renderFeed();
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-A')
+			).toBeInTheDocument();
+		});
+
+		await waitFor(() => {
+			expect(observers.length).toBeGreaterThan(0);
+		});
+		simulateIntersection(true);
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-D')
+			).toBeInTheDocument();
+		});
+
+		// All six trades now visible
+		expect(
+			screen.getByTestId('activity-creator-handle-A')
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('activity-creator-handle-B')
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('activity-creator-handle-C')
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('activity-creator-handle-D')
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('activity-creator-handle-E')
+		).toBeInTheDocument();
+		expect(
+			screen.getByTestId('activity-creator-handle-F')
+		).toBeInTheDocument();
+
+		// DOM order preserves page 1 above page 2 so older trades render
+		// below the more recent ones — this is the "appended below" promise.
+		const handleTestIds = Array.from(
+			container.querySelectorAll<HTMLElement>(
+				'[data-testid^="activity-creator-handle-"]'
+			)
+		).map(el => el.dataset.testid ?? '');
+		expect(handleTestIds).toEqual([
+			'activity-creator-handle-A',
+			'activity-creator-handle-B',
+			'activity-creator-handle-C',
+			'activity-creator-handle-D',
+			'activity-creator-handle-E',
+			'activity-creator-handle-F',
+		]);
+	});
+
+	// Acceptance #4: no duplicate trades in the combined list
+	it('does not render duplicate trade ids when paginated data overlaps', async () => {
+		// Simulate a backend that paginates by timestamp boundary and includes
+		// 'C' in both pages. The component should still surface each trade id
+		// exactly once.
+		const overlapPage2: WalletActivityTrade[] = [
+			{ ...page1Trades[2] }, // duplicate of 'C'
+			page2Trades[0],
+			page2Trades[1],
+			page2Trades[2],
+		];
+
+		vi.spyOn(walletActivityService, 'fetchWalletActivityPage')
+			.mockResolvedValueOnce({ trades: page1Trades, nextPage: 2 })
+			.mockResolvedValueOnce({ trades: overlapPage2, nextPage: null });
+
+		renderFeed();
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-A')
+			).toBeInTheDocument();
+		});
+		await waitFor(() => {
+			expect(observers.length).toBeGreaterThan(0);
+		});
+		simulateIntersection(true);
+
+		await waitFor(() => {
+			expect(
+				screen.getByTestId('activity-creator-handle-D')
+			).toBeInTheDocument();
+		});
+
+		// Each unique id appears in exactly one rendered row.
+		expect(
+			screen.getAllByTestId('activity-creator-handle-A')
+		).toHaveLength(1);
+		expect(
+			screen.getAllByTestId('activity-creator-handle-B')
+		).toHaveLength(1);
+		expect(
+			screen.getAllByTestId('activity-creator-handle-C')
+		).toHaveLength(1);
+		expect(
+			screen.getAllByTestId('activity-creator-handle-D')
+		).toHaveLength(1);
+		expect(
+			screen.getAllByTestId('activity-creator-handle-E')
+		).toHaveLength(1);
+		expect(
+			screen.getAllByTestId('activity-creator-handle-F')
+		).toHaveLength(1);
+
+		// Validate the rendered handle for 'C' carries the right creator
+		// so we know the deduplicated row is the original page-1 entry,
+		// not the duplicate appended by page 2.
+		expect(
+			screen.getByTestId('activity-creator-handle-C')
+		).toHaveTextContent('@mthorne');
+
+		// Across the entire document there are six handles — one per unique
+		// trade id, regardless of the duplicate appearing in both pages.
+		const allHandles = document.body.querySelectorAll(
+			'[data-testid^="activity-creator-handle-"]'
+		);
+		expect(allHandles.length).toBe(6);
+	});
+});
diff --git a/src/hooks/useWallet.ts b/src/hooks/useWallet.ts
index 506dd62..6ab531a 100644
--- a/src/hooks/useWallet.ts
+++ b/src/hooks/useWallet.ts
@@ -1,8 +1,9 @@
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { queryKeys } from '@/lib/queryKeys';
 import type { HeldKeyPosition } from '@/utils/portfolioValue.utils';
 import showToast from '@/utils/toast.util';
 import { getSignatureErrorMessage } from '@/utils/errorHandling.utils';
+import { fetchWalletActivityPage } from '@/services/walletActivity.service';
 
 export function useWalletHoldings(address: string) {
 	return useQuery<HeldKeyPosition[]>({
@@ -12,10 +13,22 @@ export function useWalletHoldings(address: string) {
 	});
 }
 
+/**
+ * Paginated wallet activity feed.
+ *
+ * #677 — uses `useInfiniteQuery` so the feed can incrementally load
+ * older trades via `fetchNextPage()` triggered by an `IntersectionObserver`
+ * sentinel mounted at the bottom of the list. The query key is the same
+ * `queryKeys.wallet.activity(address)` constant used by the original
+ * `useQuery` implementation so existing cache-key tests continue to pass.
+ */
 export function useWalletActivity(address: string) {
-	return useQuery({
+	return useInfiniteQuery({
 		queryKey: queryKeys.wallet.activity(address),
-		queryFn: async () => [],
+		queryFn: ({ pageParam }) =>
+			fetchWalletActivityPage(address, pageParam ?? 1),
+		initialPageParam: 1,
+		getNextPageParam: lastPage => lastPage.nextPage,
 		enabled: !!address,
 	});
 }
diff --git a/src/services/walletActivity.service.ts b/src/services/walletActivity.service.ts
new file mode 100644
index 0000000..ea72004
--- /dev/null
+++ b/src/services/walletActivity.service.ts
@@ -0,0 +1,82 @@
+// src/services/walletActivity.service.ts
+import { BaseApiService, type APIResponse } from './api.service';
+import { cacheManager } from '@/utils/cache.utils';
+
+/**
+ * Single wallet trade entry returned from the activity feed.
+ *
+ * Mirrors the shape consumed by the existing `TransactionHistory`
+ * component so the feed can pass entries straight through.
+ */
+export interface WalletActivityTrade {
+	id: string;
+	type: 'buy' | 'sell';
+	/** Raw creator identifier from the API — never shown in the UI. */
+	creatorId: string;
+	/** Human-readable handle used for display (e.g. instructorId). */
+	creatorHandle: string;
+	amount: number;
+	price: number;
+	timestamp: number;
+	txHash: string;
+	status: 'completed' | 'pending' | 'failed';
+}
+
+export interface WalletActivityPage {
+	trades: WalletActivityTrade[];
+	/**
+	 * The next page token. Returning `null` signals "no more pages"
+	 * which stops the infinite query from refetching.
+	 */
+	nextPage: number | null;
+}
+
+export interface GetWalletActivityParams {
+	address: string;
+	/** 1-indexed page number. */
+	page: number;
+	/** Page size; defaults to the backend's first-page count. */
+	limit?: number;
+}
+
+const ACTIVITY_CACHE_PREFIX = 'wallet_activity_';
+const ACTIVITY_PAGE_TTL_MS = 15_000;
+
+class WalletActivityService extends BaseApiService {
+	async getWalletActivity({
+		address,
+		page,
+		limit,
+	}: GetWalletActivityParams): Promise<WalletActivityPage> {
+		const cacheKey = `${ACTIVITY_CACHE_PREFIX}${address}_${page}_${limit ?? 'default'}`;
+		const cached = cacheManager.get<WalletActivityPage>(cacheKey);
+		if (cached) return cached;
+
+		try {
+			const response = await this.api.get<APIResponse<WalletActivityPage>>(
+				`/wallet/${address}/activity`,
+				{ params: { page, ...(limit ? { limit } : {}) } }
+			);
+
+			const data = response.data.data;
+			cacheManager.set(cacheKey, data, ACTIVITY_PAGE_TTL_MS);
+			return data;
+		} catch (error) {
+			throw this.handleError(error);
+		}
+	}
+}
+
+export const walletActivityService = new WalletActivityService();
+
+/**
+ * Convenience wrapper exposing the service call as a plain function so
+ * it can be swapped via `vi.spyOn` from integration tests without needing
+ * to mock the service class instance itself.
+ */
+export async function fetchWalletActivityPage(
+	address: string,
+	page: number
+): Promise<WalletActivityPage> {
+	return walletActivityService.getWalletActivity({ address, page });
+}