This amount will be locked in escrow until delivery is confirmed.
+
+
Total Cost
+
+ {formattedAmount} {currency}
+
+
+ This amount will be locked in escrow until delivery is confirmed
+
- {/* Wallet Connection Status */}
- {!isConnected ? (
-
-
+
+
+ ✓ Your payment is protected in escrow
+
+
+ ✓ Released only upon delivery confirmation
+
+
+
+ {!isWalletConnected && (
+
+
⚠️ Connect your wallet to lock this payment
- ) : (
-
-
-
- Wallet connected: {address?.slice(0, 8)}…{address?.slice(-6)}
-
-
)}
- {/* Lock Button */}
- {/* Info Text */}
-
- Your payment will be securely held until the delivery is completed and confirmed.
+
+ {isWalletConnected ? 'Wallet connected' : 'Wallet status: disconnected'}
{/* Confirmation Modal */}
- {showConfirmModal && (
-
+ {showConfirmation && (
+
+
+
+ Confirm Escrow Lock
+
+
+ You are about to lock
+
+ {formattedAmount} {currency}
+
+ in escrow. This action cannot be reversed immediately.
+
+
+
+
+
+
+
)}
);
diff --git a/features/escrow/components/__tests__/EscrowLock.test.tsx b/features/escrow/components/__tests__/EscrowLock.test.tsx
index 13cd9ea..ab312e2 100644
--- a/features/escrow/components/__tests__/EscrowLock.test.tsx
+++ b/features/escrow/components/__tests__/EscrowLock.test.tsx
@@ -1,70 +1,69 @@
+import React from 'react';
import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import { EscrowLock } from '../EscrowLock';
+import userEvent from '@testing-library/user-event';
+import { EscrowLock } from '@/features/escrow/components';
import { useEscrowLock } from '@/hooks/useEscrowLock';
-import { useWalletStore } from '@/store/walletStore';
-import { toast } from 'sonner';
+import { useToast } from '@/hooks/useToast';
jest.mock('@/hooks/useEscrowLock');
-jest.mock('@/store/walletStore');
-jest.mock('sonner');
+jest.mock('@/hooks/useToast');
-describe('EscrowLock Component', () => {
- const mockWalletAddress = '0x123...789';
- const mockDeliveryId = 'delivery-123';
- const mockAmount = 100.50;
- const mockCurrency = 'USDC';
+describe('EscrowLock', () => {
+ const mockEscrowLock = useEscrowLock as jest.MockedFunction
;
+ const mockUseToast = useToast as jest.MockedFunction;
+ const mockToast = jest.fn();
beforeEach(() => {
jest.clearAllMocks();
- });
-
- it('should display the total cost correctly', () => {
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
- });
-
- (useEscrowLock as jest.Mock).mockReturnValue({
+ mockUseToast.mockReturnValue({ toast: mockToast } as any);
+ mockEscrowLock.mockReturnValue({
isLoading: false,
error: null,
escrowId: null,
transactionHash: null,
- lockEscrow: jest.fn(),
+ lockEscrow: jest.fn().mockResolvedValue({
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ }),
reset: jest.fn(),
- });
+ } as any);
+ });
+ it('displays the total cost in large format', () => {
render(
);
- expect(screen.getByText('100.50')).toBeInTheDocument();
- expect(screen.getByText(mockCurrency)).toBeInTheDocument();
+ expect(screen.getByText('100.50 USDC')).toBeInTheDocument();
});
- it('should disable submit button when wallet is not connected', () => {
- (useWalletStore as jest.Mock).mockReturnValue({
- address: null,
- isConnected: false,
- });
+ it('shows wallet connection warning when no wallet', () => {
+ render(
+
+ );
- (useEscrowLock as jest.Mock).mockReturnValue({
- isLoading: false,
- error: null,
- escrowId: null,
- transactionHash: null,
- lockEscrow: jest.fn(),
- reset: jest.fn(),
- });
+ expect(
+ screen.getByText('⚠️ Connect your wallet to lock this payment')
+ ).toBeInTheDocument();
+ });
+ it('disables button when wallet not connected', () => {
render(
);
@@ -72,225 +71,295 @@ describe('EscrowLock Component', () => {
expect(button).toBeDisabled();
});
- it('should show spinner and disable button while loading', () => {
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
- });
-
- (useEscrowLock as jest.Mock).mockReturnValue({
+ it('shows spinner during loading state', () => {
+ mockEscrowLock.mockReturnValue({
isLoading: true,
error: null,
escrowId: null,
transactionHash: null,
lockEscrow: jest.fn(),
reset: jest.fn(),
- });
+ } as any);
render(
);
- expect(screen.getByText(/Locking Payment…/i)).toBeInTheDocument();
+ expect(screen.getByText('Locking Payment…')).toBeInTheDocument();
});
- it('should show confirmation modal when lock button is clicked', async () => {
- const mockLockEscrow = jest.fn();
+ it('opens confirmation modal when lock button clicked', async () => {
+ const user = userEvent.setup();
+ render(
+
+ );
+
+ const button = screen.getByRole('button', { name: /Lock Payment in Escrow/i });
+ await user.click(button);
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
+ await waitFor(() => {
+ expect(screen.getByText('Confirm Escrow Lock')).toBeInTheDocument();
});
+ });
- (useEscrowLock as jest.Mock).mockReturnValue({
- isLoading: false,
- error: null,
- escrowId: null,
- transactionHash: null,
- lockEscrow: mockLockEscrow,
- reset: jest.fn(),
+ it('shows amount in confirmation modal', async () => {
+ const user = userEvent.setup();
+ render(
+
+ );
+
+ const button = screen.getByRole('button', { name: /Lock Payment in Escrow/i });
+ await user.click(button);
+
+ await waitFor(() => {
+ expect(screen.getByText('100.50 USDC')).toBeInTheDocument();
});
+ });
+ it('cancels confirmation and closes modal', async () => {
+ const user = userEvent.setup();
render(
);
const lockButton = screen.getByRole('button', { name: /Lock Payment in Escrow/i });
- fireEvent.click(lockButton);
+ await user.click(lockButton);
+
+ const cancelButton = screen.getByRole('button', { name: /Cancel/i });
+ await user.click(cancelButton);
await waitFor(() => {
- expect(screen.getByText(/Lock Payment in Escrow/i)).toBeInTheDocument();
- expect(screen.getByRole('dialog')).toBeInTheDocument();
+ expect(screen.queryByText('Confirm Escrow Lock')).not.toBeInTheDocument();
});
});
- it('should call lockEscrow with correct params when confirmed', async () => {
- const mockLockEscrow = jest.fn();
-
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
+ it('calls lockEscrow service when confirmed', async () => {
+ const user = userEvent.setup();
+ const mockLockEscrow = jest.fn().mockResolvedValue({
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
});
- (useEscrowLock as jest.Mock).mockReturnValue({
+ mockEscrowLock.mockReturnValue({
isLoading: false,
error: null,
- escrowId: null,
- transactionHash: null,
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
lockEscrow: mockLockEscrow,
reset: jest.fn(),
- });
+ } as any);
render(
);
const lockButton = screen.getByRole('button', { name: /Lock Payment in Escrow/i });
- fireEvent.click(lockButton);
-
- await waitFor(() => {
- expect(screen.getByRole('dialog')).toBeInTheDocument();
- });
+ await user.click(lockButton);
- const confirmButton = screen.getByRole('button', { name: /Lock Payment/i });
- fireEvent.click(confirmButton);
+ const confirmButton = screen.getByRole('button', { name: /Confirm Lock/i });
+ await user.click(confirmButton);
await waitFor(() => {
expect(mockLockEscrow).toHaveBeenCalledWith({
- deliveryId: mockDeliveryId,
- amount: mockAmount,
- currency: mockCurrency,
- walletAddress: mockWalletAddress,
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
});
});
});
- it('should display success state with transaction hash', () => {
- const mockTransactionHash = '0xabc123def456ghi789jkl';
-
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
- });
-
- (useEscrowLock as jest.Mock).mockReturnValue({
+ it('displays success state with transaction hash', () => {
+ mockEscrowLock.mockReturnValue({
isLoading: false,
error: null,
escrowId: 'escrow-123',
- transactionHash: mockTransactionHash,
+ transactionHash: '0xabc123def456789',
lockEscrow: jest.fn(),
reset: jest.fn(),
- });
+ } as any);
render(
);
- expect(screen.getByText(/Payment Locked Successfully/i)).toBeInTheDocument();
- expect(screen.getByText(/100.50 USDC/)).toBeInTheDocument();
- expect(screen.getByText(mockTransactionHash)).toBeInTheDocument();
+ expect(screen.getByText('Payment Locked Successfully!')).toBeInTheDocument();
+ expect(screen.getByText('0xabc123def456789')).toBeInTheDocument();
});
- it('should display error state', () => {
- const mockError = 'Insufficient funds in wallet';
-
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
- });
-
- (useEscrowLock as jest.Mock).mockReturnValue({
+ it('displays error state with message', () => {
+ mockEscrowLock.mockReturnValue({
isLoading: false,
- error: mockError,
+ error: 'Insufficient funds in wallet',
escrowId: null,
transactionHash: null,
lockEscrow: jest.fn(),
reset: jest.fn(),
- });
+ } as any);
render(
);
- expect(screen.getByText(/Failed to Lock Payment/i)).toBeInTheDocument();
- expect(screen.getByText(mockError)).toBeInTheDocument();
+ expect(screen.getByText('Error Locking Payment')).toBeInTheDocument();
+ expect(screen.getByText('Insufficient funds in wallet')).toBeInTheDocument();
});
- it('should call onSuccess callback when escrow is locked', async () => {
+ it('calls onSuccess callback with escrowId and transactionHash', async () => {
const mockOnSuccess = jest.fn();
- const mockTransactionHash = '0xabc123def456ghi789jkl';
-
- (useWalletStore as jest.Mock).mockReturnValue({
- address: mockWalletAddress,
- isConnected: true,
+ const mockLockEscrow = jest.fn().mockResolvedValue({
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
});
- (useEscrowLock as jest.Mock).mockReturnValue({
+ mockEscrowLock.mockReturnValue({
isLoading: false,
error: null,
escrowId: 'escrow-123',
- transactionHash: mockTransactionHash,
- lockEscrow: jest.fn(),
+ transactionHash: '0xabc123',
+ lockEscrow: mockLockEscrow,
reset: jest.fn(),
- });
+ } as any);
render(
);
- await waitFor(() => {
- expect(mockOnSuccess).toHaveBeenCalledWith('escrow-123', mockTransactionHash);
- });
+ expect(mockOnSuccess).toHaveBeenCalledWith('escrow-123', '0xabc123');
});
- it('should show wallet connection warning when not connected', () => {
- (useWalletStore as jest.Mock).mockReturnValue({
- address: null,
- isConnected: false,
- });
+ it('calls onError callback with error message', () => {
+ const mockOnError = jest.fn();
+ mockEscrowLock.mockReturnValue({
+ isLoading: false,
+ error: 'Failed to lock escrow',
+ escrowId: null,
+ transactionHash: null,
+ lockEscrow: jest.fn(),
+ reset: jest.fn(),
+ } as any);
+
+ render(
+
+ );
+
+ expect(mockOnError).toHaveBeenCalledWith('Failed to lock escrow');
+ });
- (useEscrowLock as jest.Mock).mockReturnValue({
+ it('shows reset button in success state', () => {
+ mockEscrowLock.mockReturnValue({
isLoading: false,
error: null,
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ lockEscrow: jest.fn(),
+ reset: jest.fn(),
+ } as any);
+
+ render(
+
+ );
+
+ expect(screen.getByRole('button', { name: /Lock Another Delivery/i })).toBeInTheDocument();
+ });
+
+ it('shows try again button in error state', () => {
+ mockEscrowLock.mockReturnValue({
+ isLoading: false,
+ error: 'Failed',
escrowId: null,
transactionHash: null,
lockEscrow: jest.fn(),
reset: jest.fn(),
- });
+ } as any);
+
+ render(
+
+ );
+
+ expect(screen.getByRole('button', { name: /Try Again/i })).toBeInTheDocument();
+ });
+
+ it('shows wallet status when disconnected', () => {
+ render(
+
+ );
+
+ expect(screen.getByText('Wallet status: disconnected')).toBeInTheDocument();
+ });
+ it('shows wallet status when connected', () => {
render(
);
- expect(screen.getByText(/Connect your wallet to lock this payment/i)).toBeInTheDocument();
+ expect(screen.getByText('Wallet status: connected')).toBeInTheDocument();
});
});
diff --git a/hooks/__tests__/useEscrowLock.test.ts b/hooks/__tests__/useEscrowLock.test.ts
new file mode 100644
index 0000000..8ea15b3
--- /dev/null
+++ b/hooks/__tests__/useEscrowLock.test.ts
@@ -0,0 +1,261 @@
+import { renderHook, act } from '@testing-library/react';
+import { useEscrowLock } from '@/hooks/useEscrowLock';
+import { escrowService, LockEscrowParams } from '@/services/escrowService';
+
+jest.mock('@/services/escrowService');
+
+describe('useEscrowLock', () => {
+ const mockEscrowService = escrowService as jest.Mocked;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('initializes with idle state', () => {
+ const { result } = renderHook(() => useEscrowLock());
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.error).toBeNull();
+ expect(result.current.escrowId).toBeNull();
+ expect(result.current.transactionHash).toBeNull();
+ });
+
+ it('sets isLoading to true before lock request', async () => {
+ let loadingState: boolean | null = null;
+
+ mockEscrowService.lockEscrow.mockImplementation(async () => {
+ loadingState = true;
+ return {
+ success: true,
+ message: 'Locked',
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc',
+ lockedAmount: '100',
+ };
+ });
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100,
+ currency: 'USDC',
+ walletAddress: '0x123',
+ });
+ } catch {}
+ });
+
+ expect(loadingState).toBe(true);
+ });
+
+ it('sets state on successful lock', async () => {
+ mockEscrowService.lockEscrow.mockResolvedValue({
+ success: true,
+ message: 'Locked',
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ lockedAmount: '100.50',
+ });
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ await act(async () => {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ });
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.error).toBeNull();
+ expect(result.current.escrowId).toBe('escrow-123');
+ expect(result.current.transactionHash).toBe('0xabc123');
+ });
+
+ it('sets error state on lock failure', async () => {
+ const error = new Error('Insufficient funds');
+ mockEscrowService.lockEscrow.mockRejectedValue(error);
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ } catch {}
+ });
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.error).toBe('Insufficient funds');
+ expect(result.current.escrowId).toBeNull();
+ expect(result.current.transactionHash).toBeNull();
+ });
+
+ it('passes correct parameters to service', async () => {
+ mockEscrowService.lockEscrow.mockResolvedValue({
+ success: true,
+ message: 'Locked',
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ lockedAmount: '100.50',
+ });
+
+ const { result } = renderHook(() => useEscrowLock());
+ const params: LockEscrowParams = {
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ };
+
+ await act(async () => {
+ await result.current.lockEscrow(params);
+ });
+
+ expect(mockEscrowService.lockEscrow).toHaveBeenCalledWith(params);
+ });
+
+ it('resets state to initial values', async () => {
+ mockEscrowService.lockEscrow.mockResolvedValue({
+ success: true,
+ message: 'Locked',
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ lockedAmount: '100.50',
+ });
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ // Lock escrow
+ await act(async () => {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ });
+
+ expect(result.current.escrowId).toBe('escrow-123');
+
+ // Reset
+ act(() => {
+ result.current.reset();
+ });
+
+ expect(result.current.isLoading).toBe(false);
+ expect(result.current.error).toBeNull();
+ expect(result.current.escrowId).toBeNull();
+ expect(result.current.transactionHash).toBeNull();
+ });
+
+ it('handles generic error messages', async () => {
+ mockEscrowService.lockEscrow.mockRejectedValue(new Error('Network error'));
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ } catch {}
+ });
+
+ expect(result.current.error).toBe('Network error');
+ });
+
+ it('handles non-Error exceptions', async () => {
+ mockEscrowService.lockEscrow.mockRejectedValue('Unknown error');
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ } catch {}
+ });
+
+ expect(result.current.error).toBe('Failed to lock escrow');
+ });
+
+ it('throws error after setting state', async () => {
+ const error = new Error('Lock failed');
+ mockEscrowService.lockEscrow.mockRejectedValue(error);
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ let thrownError: Error | null = null;
+
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ } catch (err) {
+ thrownError = err as Error;
+ }
+ });
+
+ expect(thrownError).toBe(error);
+ });
+
+ it('clears previous error on retry', async () => {
+ mockEscrowService.lockEscrow.mockRejectedValueOnce(new Error('First error'));
+ mockEscrowService.lockEscrow.mockResolvedValueOnce({
+ success: true,
+ message: 'Locked',
+ escrowId: 'escrow-123',
+ transactionHash: '0xabc123',
+ lockedAmount: '100.50',
+ });
+
+ const { result } = renderHook(() => useEscrowLock());
+
+ // First attempt - fails
+ await act(async () => {
+ try {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ } catch {}
+ });
+
+ expect(result.current.error).toBe('First error');
+
+ // Second attempt - succeeds
+ await act(async () => {
+ await result.current.lockEscrow({
+ deliveryId: 'delivery-1',
+ amount: 100.5,
+ currency: 'USDC',
+ walletAddress: '0x123...789',
+ });
+ });
+
+ expect(result.current.error).toBeNull();
+ expect(result.current.escrowId).toBe('escrow-123');
+ });
+});
diff --git a/hooks/useDeliveries.ts b/hooks/useDeliveries.ts
index 07facd1..7a19913 100644
--- a/hooks/useDeliveries.ts
+++ b/hooks/useDeliveries.ts
@@ -1,11 +1,12 @@
import { useQuery } from '@tanstack/react-query';
import { deliveriesService } from '../services/deliveries.service';
import { Delivery } from '../types/delivery';
+import { DeliveryFilterParams } from '../types/filters';
-export function useDeliveries() {
+export function useDeliveries(filters?: DeliveryFilterParams) {
return useQuery({
- queryKey: ['deliveries'],
- queryFn: deliveriesService.getDeliveries,
+ queryKey: ['deliveries', filters],
+ queryFn: () => deliveriesService.getDeliveries(filters),
});
}
diff --git a/hooks/useEscrowLock.ts b/hooks/useEscrowLock.ts
index 100c03f..fb58113 100644
--- a/hooks/useEscrowLock.ts
+++ b/hooks/useEscrowLock.ts
@@ -1,80 +1,57 @@
+'use client';
+
import { useState, useCallback } from 'react';
-import { toast } from 'sonner';
-import { escrowService, LockEscrowParams, LockEscrowResponse } from '@/services/escrowService';
+import { escrowService, LockEscrowParams } from '@/services/escrowService';
-interface UseEscrowLockReturn {
+interface UseEscrowLockState {
isLoading: boolean;
error: string | null;
escrowId: string | null;
transactionHash: string | null;
- lockEscrow: (params: LockEscrowParams) => Promise;
- reset: () => void;
}
/**
- * useEscrowLock — manages the escrow fund locking flow.
- *
- * Handles:
- * 1. API request to lock funds in escrow
- * 2. Loading state management
- * 3. Error handling with toast notifications
- * 4. Success state with transaction hash
- *
- * Components use this hook to lock escrow payments for deliveries.
- * The hook calls escrowService; the component never calls the service directly.
+ * Hook for managing escrow lock state and API communication
+ * Follows Component → Hook → Service pattern
*/
-export function useEscrowLock(): UseEscrowLockReturn {
- const [isLoading, setIsLoading] = useState(false);
- const [error, setError] = useState(null);
- const [escrowId, setEscrowId] = useState(null);
- const [transactionHash, setTransactionHash] = useState(null);
+export function useEscrowLock() {
+ const [state, setState] = useState({
+ isLoading: false,
+ error: null,
+ escrowId: null,
+ transactionHash: null,
+ });
- const lockEscrow = useCallback(async (params: LockEscrowParams): Promise => {
- setIsLoading(true);
- setError(null);
+ const lockEscrow = useCallback(async (params: LockEscrowParams) => {
+ setState({ isLoading: true, error: null, escrowId: null, transactionHash: null });
try {
- const response: LockEscrowResponse = await escrowService.lockEscrow(params);
-
- if (!response.success) {
- const errorMessage = response.message ?? 'Failed to lock escrow. Please try again.';
- setError(errorMessage);
- toast.error(errorMessage);
- return;
- }
-
- setEscrowId(response.escrowId ?? null);
- setTransactionHash(response.transactionHash ?? null);
-
- toast.success(
- response.transactionHash
- ? `Escrow locked! Tx: ${response.transactionHash.slice(0, 12)}…`
- : 'Escrow payment locked successfully!'
- );
- } catch (err: unknown) {
- const errorMessage =
- err instanceof Error
- ? err.message
- : 'An unexpected error occurred while locking escrow. Please try again.';
- setError(errorMessage);
- toast.error(errorMessage);
- } finally {
- setIsLoading(false);
+ const response = await escrowService.lockEscrow(params);
+ setState({
+ isLoading: false,
+ error: null,
+ escrowId: response.escrowId,
+ transactionHash: response.transactionHash,
+ });
+ return response;
+ } catch (err) {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to lock escrow';
+ setState({
+ isLoading: false,
+ error: errorMessage,
+ escrowId: null,
+ transactionHash: null,
+ });
+ throw err;
}
}, []);
const reset = useCallback(() => {
- setIsLoading(false);
- setError(null);
- setEscrowId(null);
- setTransactionHash(null);
+ setState({ isLoading: false, error: null, escrowId: null, transactionHash: null });
}, []);
return {
- isLoading,
- error,
- escrowId,
- transactionHash,
+ ...state,
lockEscrow,
reset,
};
diff --git a/services/__tests__/deliveries.service.test.ts b/services/__tests__/deliveries.service.test.ts
new file mode 100644
index 0000000..910d14b
--- /dev/null
+++ b/services/__tests__/deliveries.service.test.ts
@@ -0,0 +1,104 @@
+import { deliveriesService } from '@/services/deliveries.service';
+import { apiClient } from '@/services/api';
+
+jest.mock('@/services/api');
+
+describe('deliveriesService', () => {
+ const mockApiClient = apiClient as jest.Mocked;
+
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ it('fetches deliveries without filters', async () => {
+ const mockData = [
+ {
+ id: '1',
+ trackingNumber: 'TRK001',
+ status: 'PENDING',
+ origin: 'NYC',
+ destination: 'LA',
+ amount: 100,
+ createdAt: '2024-01-01',
+ updatedAt: '2024-01-01',
+ },
+ ];
+
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ const result = await deliveriesService.getDeliveries();
+
+ expect(mockApiClient.get).toHaveBeenCalledWith('/deliveries');
+ expect(result).toEqual(mockData);
+ });
+
+ it('fetches deliveries with search filter', async () => {
+ const mockData = [];
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ await deliveriesService.getDeliveries({ search: 'TRK123' });
+
+ expect(mockApiClient.get).toHaveBeenCalledWith('/deliveries?search=TRK123');
+ });
+
+ it('fetches deliveries with status filter', async () => {
+ const mockData = [];
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ await deliveriesService.getDeliveries({ status: 'DELIVERED' });
+
+ expect(mockApiClient.get).toHaveBeenCalledWith('/deliveries?status=DELIVERED');
+ });
+
+ it('fetches deliveries with sortBy filter', async () => {
+ const mockData = [];
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ await deliveriesService.getDeliveries({ sortBy: 'date-desc' });
+
+ expect(mockApiClient.get).toHaveBeenCalledWith('/deliveries?sortBy=date-desc');
+ });
+
+ it('fetches deliveries with multiple filters', async () => {
+ const mockData = [];
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ await deliveriesService.getDeliveries({
+ search: 'TRK456',
+ status: 'IN_TRANSIT',
+ sortBy: 'date-asc',
+ });
+
+ const call = mockApiClient.get.mock.calls[0][0];
+ expect(call).toContain('search=TRK456');
+ expect(call).toContain('status=IN_TRANSIT');
+ expect(call).toContain('sortBy=date-asc');
+ });
+
+ it('fetches delivery by ID', async () => {
+ const mockData = {
+ id: '1',
+ trackingNumber: 'TRK001',
+ status: 'PENDING',
+ origin: 'NYC',
+ destination: 'LA',
+ amount: 100,
+ createdAt: '2024-01-01',
+ updatedAt: '2024-01-01',
+ };
+
+ mockApiClient.get.mockResolvedValue({ data: mockData });
+
+ const result = await deliveriesService.getDeliveryById('1');
+
+ expect(mockApiClient.get).toHaveBeenCalledWith('/deliveries/1');
+ expect(result).toEqual(mockData);
+ });
+
+ it('handles API errors gracefully', async () => {
+ const error = new Error('API Error');
+ mockApiClient.get.mockRejectedValue(error);
+
+ await expect(deliveriesService.getDeliveries()).rejects.toThrow('API Error');
+ });
+});
diff --git a/services/deliveries.service.ts b/services/deliveries.service.ts
index 30e305a..3af4878 100644
--- a/services/deliveries.service.ts
+++ b/services/deliveries.service.ts
@@ -1,5 +1,6 @@
import { apiClient } from './api';
-import { Delivery, StatusTimeline } from '../types/delivery';
+import { Delivery } from '../types/delivery';
+import { DeliveryFilterParams } from '../types/filters';
export interface CreateDeliveryPayload {
pickupAddress: string;
@@ -12,20 +13,27 @@ export interface CreateDeliveryPayload {
}
export const deliveriesService = {
- getDeliveries: async (): Promise => {
- const { data } = await apiClient.get('/deliveries');
+ getDeliveries: async (filters?: DeliveryFilterParams): Promise => {
+ let url = '/deliveries';
+
+ if (filters) {
+ const params = new URLSearchParams();
+ if (filters.search) params.append('search', filters.search);
+ if (filters.status) params.append('status', filters.status);
+ if (filters.sortBy) params.append('sortBy', filters.sortBy);
+
+ const queryString = params.toString();
+ if (queryString) {
+ url += `?${queryString}`;
+ }
+ }
+
+ const { data } = await apiClient.get(url);
return data;
},
getDeliveryById: async (id: string): Promise => {
const { data } = await apiClient.get(`/deliveries/${id}`);
return data;
- },
-
- getStatusTimeline: async (deliveryId: string): Promise => {
- const { data } = await apiClient.get(
- `/deliveries/${deliveryId}/timeline`
- );
- return data;
}
};
diff --git a/services/escrowService.ts b/services/escrowService.ts
index 34c33c5..790a23a 100644
--- a/services/escrowService.ts
+++ b/services/escrowService.ts
@@ -28,46 +28,25 @@ export interface ReleaseEscrowResponse {
releasedAmount?: string;
}
-export interface LockEscrowParams {
- deliveryId: string;
- amount: number;
- currency: string;
- walletAddress: string;
-}
-
-export interface LockEscrowResponse {
- success: boolean;
- message: string;
- escrowId?: string;
- transactionHash?: string;
- lockedAmount?: string;
-}
-
export interface ApiResponse {
success: boolean;
message: string;
data?: T;
}
-export interface DisputeEvidenceFile {
- file: File;
- description?: string;
-}
-
-export interface OpenDisputeParams {
+export interface LockEscrowParams {
deliveryId: string;
- transactionId: string;
- reason: 'damaged_items' | 'non_delivery' | 'incorrect_items' | 'other';
- description: string;
- evidenceFiles?: File[];
+ amount: number;
+ currency: string;
walletAddress: string;
}
-export interface OpenDisputeResponse {
+export interface LockEscrowResponse {
success: boolean;
message: string;
- disputeId?: string;
- transactionHash?: string;
+ escrowId: string;
+ transactionHash: string;
+ lockedAmount: string;
}
/**
@@ -75,14 +54,6 @@ export interface OpenDisputeResponse {
* The hook calls this; components never call this directly.
*/
export const escrowService = {
- async lockEscrow(params: LockEscrowParams): Promise {
- const { data } = await axios.post(
- `${API_BASE_URL}/api/escrow/lock`,
- params
- );
- return data;
- },
-
async getEscrowDetails(escrowId: string): Promise> {
const { data } = await axios.get>(
`${API_BASE_URL}/api/escrow/${escrowId}`
@@ -106,28 +77,10 @@ export const escrowService = {
return data;
},
- async openDispute(params: OpenDisputeParams): Promise {
- const formData = new FormData();
- formData.append('deliveryId', params.deliveryId);
- formData.append('transactionId', params.transactionId);
- formData.append('reason', params.reason);
- formData.append('description', params.description);
- formData.append('walletAddress', params.walletAddress);
-
- if (params.evidenceFiles && params.evidenceFiles.length > 0) {
- params.evidenceFiles.forEach((file, index) => {
- formData.append(`evidenceFiles`, file);
- });
- }
-
- const { data } = await axios.post(
- `${API_BASE_URL}/api/escrow/dispute`,
- formData,
- {
- headers: {
- 'Content-Type': 'multipart/form-data',
- },
- }
+ async lockEscrow(params: LockEscrowParams): Promise {
+ const { data } = await axios.post(
+ `${API_BASE_URL}/api/escrow/lock`,
+ params
);
return data;
},
diff --git a/tailwind.config.ts b/tailwind.config.ts
index 1f12457..7e3e8ab 100644
--- a/tailwind.config.ts
+++ b/tailwind.config.ts
@@ -1,5 +1,7 @@
+// @ts-ignore - Tailwind CSS v4 type resolution
import type { Config } from 'tailwindcss';
+// Tailwind CSS configuration
const config: Config = {
darkMode: 'class',
content: [
diff --git a/tsconfig.json b/tsconfig.json
index b09cc80..fb87bad 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,6 +1,6 @@
{
"compilerOptions": {
- "target": "es5",
+ "target": "es2020",
"lib": [
"dom",
"dom.iterable",
@@ -8,6 +8,7 @@
],
"allowJs": true,
"skipLibCheck": true,
+ "ignoreDeprecations": "6.0",
"strict": true,
"noEmit": true,
"esModuleInterop": true,
diff --git a/types/filters.ts b/types/filters.ts
new file mode 100644
index 0000000..10ec575
--- /dev/null
+++ b/types/filters.ts
@@ -0,0 +1,15 @@
+/**
+ * Filter type definitions for delivery list
+ */
+
+export type DeliveryStatus = 'PENDING' | 'ACCEPTED' | 'IN_TRANSIT' | 'DELIVERED' | 'CANCELLED';
+
+export interface DeliveryFilterParams {
+ search?: string;
+ status?: DeliveryStatus;
+ sortBy?: 'date-asc' | 'date-desc';
+}
+
+export interface FilterState extends DeliveryFilterParams {
+ hasActiveFilters: boolean;
+}