diff --git a/CODE_REVIEW.md b/CODE_REVIEW.md
new file mode 100644
index 0000000..abcf763
--- /dev/null
+++ b/CODE_REVIEW.md
@@ -0,0 +1,403 @@
+# Code Review Report: Safe CLI
+
+**Date:** 2025-10-26
+**Version:** 0.1.0
+**Reviewer:** Claude Code
+
+---
+
+## 🐛 **BUGS FOUND**
+
+### 1. **CRITICAL: Inconsistent Storage Project Name**
+**Location:** `src/storage/transaction-store.ts:20`
+
+The transaction store uses a different `projectName` than all other stores:
+- **transaction-store.ts**: `'safe-cli-nodejs'`
+- **All others**: `'safe-cli'`
+
+**Impact:** This causes transactions to be stored in a different directory than other config files, leading to:
+- Confusion when debugging
+- Potential data loss if users migrate or backup only one directory
+- Inconsistent uninstall/cleanup behavior
+
+**Fix:** Change line 20 in `transaction-store.ts` to use `'safe-cli'`
+
+---
+
+### 2. **Date Serialization Issue**
+**Location:** `src/storage/transaction-store.ts:44, 127`
+
+The `createdAt` and `executedAt` fields are typed as `Date` objects, but `Conf` stores them as JSON which serializes dates as strings. When reading back from storage, they remain strings but TypeScript expects `Date` objects.
+
+**Impact:**
+- Type safety violation at runtime
+- Potential crashes if code tries to call `.getTime()` or other Date methods
+- Inconsistent behavior between fresh objects and persisted ones
+
+**Fix:** Either:
+- Change types to `string` and document ISO format
+- Add serialization/deserialization logic in `createTransaction()` and `getTransaction()`
+
+---
+
+### 3. **Missing Error Handling in fetch() Calls**
+**Location:** `src/services/abi-service.ts:135, 168, 197`
+
+The `fetch()` calls for Etherscan and Sourcify APIs lack proper timeout and error handling:
+
+```typescript
+const response = await fetch(requestUrl) // No timeout!
+```
+
+**Impact:**
+- CLI can hang indefinitely on slow/unresponsive networks
+- Poor user experience with no feedback
+- No retry logic for transient failures
+
+**Fix:** Add timeout wrapper and proper error handling:
+```typescript
+const controller = new AbortController()
+const timeoutId = setTimeout(() => controller.abort(), 10000) // 10s timeout
+try {
+  const response = await fetch(requestUrl, { signal: controller.signal })
+  // ... handle response
+} finally {
+  clearTimeout(timeoutId)
+}
+```
+
+---
+
+### 4. **Potential Race Condition in Password Management**
+**Location:** `src/storage/wallet-store.ts:60, 82-84`
+
+The `password` field is stored as instance state (`this.password: string | null = null`), but the singleton pattern means multiple operations could interfere with each other.
+
+**Impact:**
+- If one command sets a password and another command runs concurrently, they could use the wrong password
+- Minimal risk in current CLI usage (sequential commands) but problematic if converted to server/daemon
+
+**Fix:** Consider passing password explicitly to methods that need it, or use a more robust session management system.
+
+---
+
+### 5. **Unsafe parseInt Without Radix**
+**Location:** Multiple files (safe-service.ts, transaction-service.ts)
+
+Several `parseInt(this.chain.chainId)` calls lack explicit radix parameter:
+
+```typescript
+id: parseInt(this.chain.chainId), // Missing radix!
+```
+
+**Impact:**
+- Inconsistent parsing if chainId has leading zeros
+- Potential security issue with malformed input
+
+**Fix:** Always specify radix: `parseInt(this.chain.chainId, 10)`
+
+---
+
+## 💧 **MEMORY LEAKS & RESOURCE MANAGEMENT**
+
+### 1. **Ink Render Memory Leak Risk**
+**Location:** `src/ui/render.tsx:22-27`
+
+The `renderScreen()` function properly handles unmounting, BUT there's a subtle issue: if an error occurs before `waitUntilExit()` resolves, the component is never unmounted.
+
+**Current code:**
+```typescript
+waitUntilExit().then(() => {
+  unmount()
+  resolve()
+})
+```
+
+**Risk:** If the component throws an error or process exits unexpectedly, `unmount()` is never called.
+
+**Fix:** Add error handling:
+```typescript
+waitUntilExit()
+  .then(() => {
+    unmount()
+    resolve()
+  })
+  .catch((error) => {
+    unmount() // Always cleanup
+    reject(error)
+  })
+```
+
+---
+
+### 2. **No Cleanup for Public/Wallet Clients**
+**Location:** `src/services/safe-service.ts`, `src/services/transaction-service.ts`
+
+Multiple viem clients are created but never explicitly cleaned up:
+- `createPublicClient()` at safe-service.ts:137, 169
+- `createWalletClient()` at safe-service.ts:112
+- `createPublicClient()` at transaction-service.ts:181
+
+**Impact:**
+- Connection pooling may hold open sockets
+- Small memory leak per operation
+- Not critical for CLI (short-lived processes) but problematic if CLI becomes long-running
+
+**Fix:** Store clients as instance properties and reuse them, or implement cleanup in a `destroy()` method.
+
+---
+
+### 3. **process.setMaxListeners(20) Warning**
+**Location:** `src/index.ts:5`
+
+While this suppresses warnings, it masks potential event listener leaks. The comment mentions "sequential command chaining" but doesn't address the root cause.
+
+**Risk:** If there's a legitimate listener leak, this hides it.
+
+**Recommendation:** Audit event listeners and ensure proper cleanup, then reduce this number to the actual required amount.
+
+---
+
+## 🏗️ **ARCHITECTURE IMPROVEMENTS**
+
+### 1. **Service Instantiation Duplication**
+**Pattern:** Services are instantiated repeatedly in commands with the same parameters.
+
+Example from `tx/create.ts:85, 361`:
+```typescript
+const txService = new TransactionService(chain)
+// ... later ...
+const txService = new TransactionService(chain) // Duplicate instantiation!
+```
+
+**Improvement:** Create a service factory/registry:
+```typescript
+class ServiceRegistry {
+  private services = new Map()
+
+  getTransactionService(chain: ChainConfig, privateKey?: string) {
+    const key = `${chain.chainId}:${privateKey || 'readonly'}`
+    if (!this.services.has(key)) {
+      this.services.set(key, new TransactionService(chain, privateKey))
+    }
+    return this.services.get(key)
+  }
+}
+```
+
+---
+
+### 2. **No Dependency Injection**
+**Issue:** All commands directly call `getConfigStore()`, `getWalletStorage()`, etc., creating tight coupling.
+
+**Impact:**
+- Hard to unit test commands in isolation
+- Hard to mock storage for tests
+- Difficult to swap implementations
+
+**Improvement:** Use constructor injection or a DI container:
+```typescript
+export async function createTransaction(deps = {
+  safeStorage: getSafeStorage(),
+  configStore: getConfigStore(),
+  // ...
+}) {
+  // Use deps.safeStorage instead of getSafeStorage()
+}
+```
+
+---
+
+### 3. **Missing Validation Layer** ✅ **FIXED**
+**Issue:** Validation logic was scattered throughout commands and services.
+
+Example: Address validation happened inline in multiple places:
+- `tx/create.ts:108-112`
+- Throughout various services
+- No centralized validation rules
+
+**Solution Implemented:** Created `ValidationService` class in `src/services/validation-service.ts`:
+- Centralized validation for all input types (addresses, private keys, chain IDs, URLs, etc.)
+- Two types of validators: `validate*()` for prompts, `assert*()` for business logic
+- Updated multiple commands to use the service: wallet/import.ts, config/chains.ts, tx/create.ts, account/create.ts
+- Consistent error messages across the application
+- Easier to test and maintain validation logic
+
+---
+
+### 4. **No Retry Logic for Network Operations**
+**Issue:** All RPC and API calls fail immediately on network errors.
+
+**Improvement:** Implement exponential backoff retry wrapper:
+```typescript
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  maxRetries = 3,
+  baseDelay = 1000
+): Promise<T> {
+  // Implementation with exponential backoff
+}
+```
+
+---
+
+### 5. **Hardcoded Safe Version**
+**Location:** Multiple files specify `safeVersion: '1.4.1'`
+
+While there's a default in config, services hardcode the version:
+- `safe-service.ts:54`
+- `safe-service.ts:103`
+
+**Improvement:** Always read from config, allow per-safe version override.
+
+---
+
+## ♻️ **REFACTORING OPPORTUNITIES**
+
+### 1. **Extract Chain Client Factory**
+**Current:** Chain client creation is duplicated across services.
+
+**Refactor:** Create a `ChainClientFactory`:
+```typescript
+class ChainClientFactory {
+  createPublicClient(chain: ChainConfig) { ... }
+  createWalletClient(chain: ChainConfig, privateKey: string) { ... }
+}
+```
+
+---
+
+### 2. **Consolidate Address Formatting**
+**Issue:** EIP-3770 formatting logic is called inline throughout commands.
+
+**Refactor:** Create a display service:
+```typescript
+class DisplayService {
+  formatAddress(address: Address, chainId: string): string
+  formatBalance(balance: bigint, decimals: number): string
+  formatTimestamp(date: Date | string): string
+}
+```
+
+---
+
+### 3. **Extract Prompt Patterns**
+**Issue:** Similar prompt patterns repeated in many commands:
+
+```typescript
+// Repeated pattern:
+const safes = safeStorage.getAllSafes()
+if (safes.length === 0) {
+  p.log.error('No Safes found. Please create a Safe first.')
+  p.outro('Setup required')
+  return
+}
+```
+
+**Refactor:** Create prompt utilities:
+```typescript
+async function promptSafeSelection(message: string): Promise<SafeAccount>
+async function promptWalletPassword(): Promise<string>
+async function confirmAction(message: string): Promise<boolean>
+```
+
+---
+
+### 4. **Separate UI from Business Logic**
+**Issue:** Commands mix @clack/prompts UI code with business logic, making it hard to:
+- Test business logic separately
+- Build alternative interfaces (web UI, programmatic API)
+
+**Refactor:** Split into:
+- **UI Layer**: Handles prompts and rendering
+- **Controller Layer**: Orchestrates business logic
+- **Service Layer**: Pure business operations
+
+---
+
+### 5. **Type Guard Functions**
+**Issue:** Type narrowing is done inline throughout:
+
+```typescript
+if (error instanceof Error) { ... }
+if (error instanceof SafeCLIError) { ... }
+```
+
+**Refactor:** Create type guards:
+```typescript
+function isSafeCLIError(error: unknown): error is SafeCLIError
+function isNetworkError(error: unknown): error is NetworkError
+```
+
+---
+
+### 6. **Extract Transaction Builder to UI Pattern**
+**Issue:** `tx/create.ts` is 449 lines with complex nested logic.
+
+**Refactor:** Break into smaller functions:
+- `getTransactionTarget(): Promise<Address>`
+- `getContractInteraction(address: Address): Promise<TransactionData>`
+- `getManualTransaction(): Promise<TransactionData>`
+- `confirmTransaction(data: TransactionData): Promise<boolean>`
+
+---
+
+## 🔒 **SECURITY CONSIDERATIONS**
+
+### 1. **Encryption Salt Not Truly Random in Tests**
+If tests mock `randomBytes`, they might use predictable values. Ensure test infrastructure properly handles crypto operations.
+
+### 2. **Private Key Clearance**
+Consider explicitly clearing private keys from memory after use:
+```typescript
+// After using privateKey
+privateKey = '0x' + '0'.repeat(64) // Overwrite in memory
+```
+
+### 3. **API Key Logging Risk**
+`config/show.ts` obfuscates API keys in display, but ensure they're never logged to error messages or debug output.
+
+---
+
+## 📊 **SUMMARY STATISTICS**
+
+| Category | Count | Severity |
+|----------|-------|----------|
+| Critical Bugs | 1 | High |
+| Major Bugs | 4 | Medium |
+| Memory Leak Risks | 3 | Medium |
+| Architecture Issues | 5 | Medium |
+| Refactoring Opportunities | 6 | Low |
+
+---
+
+## 🎯 **RECOMMENDED PRIORITY ORDER**
+
+1. ✅ **Fix critical bug**: Inconsistent storage projectName (FIXED)
+2. ✅ **Fix date serialization**: Transaction store dates (FIXED)
+3. ✅ **Add fetch timeouts**: Prevent hanging on network calls (FIXED)
+4. ✅ **Add validation layer**: Centralize validation logic (FIXED)
+5. ✅ **Fix unsafe parseInt**: Add radix parameter (FIXED)
+6. **Implement retry logic**: Improve reliability
+7. **Extract service factory**: Reduce duplication
+8. **Refactor large commands**: Break down tx/create.ts
+9. **Add DI support**: Improve testability
+
+---
+
+## 📝 **NOTES**
+
+The codebase is generally **well-structured and follows good TypeScript practices**. The issues found are mostly about edge cases, operational robustness, and opportunities for improved maintainability. The critical bug (projectName inconsistency) should be fixed immediately, while other improvements can be addressed incrementally.
+
+**Strengths:**
+- Clean architecture with good separation of concerns
+- Comprehensive type safety with TypeScript and Zod
+- Modern React/Ink UI for great UX
+- Secure wallet encryption with AES-256-GCM
+- Well-documented code with clear patterns
+
+**Areas for Improvement:**
+- Network resilience (timeouts, retries)
+- Resource cleanup and memory management
+- Dependency injection for better testability
+- Reduced code duplication in commands
diff --git a/MIGRATION_PLAN.md b/MIGRATION_PLAN.md
deleted file mode 100644
index 09609e8..0000000
--- a/MIGRATION_PLAN.md
+++ /dev/null
@@ -1,720 +0,0 @@
-# Migration Plan: Imperative Console → Reactive Ink Architecture
-
-## Current State Summary
-- **561 console occurrences** (primarily console.log)
-- Mixed UI patterns: @clack/prompts for interactive input + raw console.log for output
-- Heavy usage in: account commands (34-26 instances), config commands (27-21), tx/wallet commands (19-10)
-- Good separation: services layer already isolated from commands
-- Manual formatting for tables, lists, and structured data
-
----
-
-## Phase 1: Foundation & Infrastructure (Week 1)
-
-### 1.1 Add Ink Dependencies
-```bash
-npm install ink react
-npm install --save-dev @types/react
-```
-
-### 1.2 Create Core Architecture
-**New directory structure:**
-```
-src/
-├── ui/
-│   ├── components/          # Reusable Ink components
-│   │   ├── Layout.tsx       # Container, Box, Text wrappers
-│   │   ├── Table.tsx        # Generic table component
-│   │   ├── List.tsx         # List with markers
-│   │   ├── KeyValue.tsx     # Key-value pairs display
-│   │   ├── Header.tsx       # Styled headers/titles
-│   │   ├── StatusBadge.tsx  # Status indicators
-│   │   └── Spinner.tsx      # Loading states
-│   ├── screens/             # Full-screen views
-│   │   ├── WelcomeScreen.tsx
-│   │   ├── AccountListScreen.tsx
-│   │   ├── AccountInfoScreen.tsx
-│   │   └── ...
-│   ├── hooks/               # Custom React hooks
-│   │   ├── useConfig.ts     # Config state management
-│   │   ├── useSafe.ts       # Safe state management
-│   │   └── useWallet.ts     # Wallet state management
-│   ├── theme.ts             # Color palette and styles
-│   └── render.tsx           # Ink render wrapper utility
-```
-
-### 1.3 Create Render Utility
-**Purpose:** Bridge between command functions and Ink rendering
-```typescript
-// src/ui/render.tsx
-import { render } from 'ink'
-import React from 'react'
-
-export function renderScreen<T>(
-  Component: React.ComponentType<T>,
-  props: T
-): Promise<void> {
-  return new Promise((resolve) => {
-    const { unmount, waitUntilExit } = render(<Component {...props} />)
-    waitUntilExit().then(() => {
-      unmount()
-      resolve()
-    })
-  })
-}
-```
-
----
-
-## Phase 2: Component Library (Week 2)
-
-### 2.1 Build Core Components
-
-**Priority components based on usage patterns:**
-
-1. **Table Component** (replaces 100+ console.log instances)
-   - Aligned columns
-   - Headers with styling
-   - Row highlighting
-   - Used in: account info, config show, tx list
-
-2. **List Component** (replaces 80+ console.log instances)
-   - Bullet markers (●/○)
-   - Active/inactive states
-   - Nested indentation
-   - Used in: account list, wallet list
-
-3. **KeyValue Component** (replaces 150+ console.log instances)
-   - Label/value pairs
-   - Consistent spacing
-   - Color theming
-   - Used in: all info/summary displays
-
-4. **Header Component** (replaces 50+ console.log instances)
-   - Title with icons
-   - Dividers
-   - Used in: all command outputs
-
-5. **StatusBadge Component** (replaces 30+ console.log instances)
-   - Success/error/warning/info
-   - Icons + colors
-   - Used in: confirmations, error messages
-
-### 2.2 Create Theme System
-**src/ui/theme.ts:**
-```typescript
-export const theme = {
-  colors: {
-    primary: '#00D9FF',    // cyan
-    success: '#00FF88',    // green
-    error: '#FF5555',      // red
-    warning: '#FFAA00',    // yellow
-    info: '#5599FF',       // blue
-    dim: '#666666',        // gray
-  },
-  spacing: {
-    small: 1,
-    medium: 2,
-    large: 3,
-  },
-}
-```
-
----
-
-## Phase 3: Logic/Presentation Separation (Week 3) ✅
-
-### 3.1 Extract Business Logic from Commands
-
-**Pattern: Command → Controller → View**
-
-**COMPLETED EXAMPLE: Wallet List Migration**
-
-**Before (imperative - 41 lines):**
-```typescript
-// commands/wallet/list.ts (OLD)
-import * as p from '@clack/prompts'
-import pc from 'picocolors'
-import { getWalletStorage } from '../../storage/wallet-store.js'
-import { shortenAddress } from '../../utils/ethereum.js'
-
-export async function listWallets() {
-  p.intro(pc.bgCyan(pc.black(' Wallets ')))
-
-  const walletStorage = getWalletStorage()
-  const wallets = walletStorage.getAllWallets()
-  const activeWallet = walletStorage.getActiveWallet()
-
-  if (wallets.length === 0) {
-    console.log('')
-    console.log(pc.dim('No wallets found'))
-    console.log('')
-    p.outro('Use "safe wallet import" to import a wallet')
-    return
-  }
-
-  console.log('')
-  for (const wallet of wallets) {
-    const isActive = activeWallet?.id === wallet.id
-    const marker = isActive ? pc.green('●') : pc.dim('○')
-    const label = isActive ? pc.bold(pc.green(wallet.name)) : wallet.name
-
-    console.log(`${marker} ${label}`)
-    console.log(`  ${pc.dim('Address:')} ${wallet.address}`)
-    console.log(`  ${pc.dim('Short:')}   ${shortenAddress(wallet.address)}`)
-    if (wallet.lastUsed) {
-      console.log(`  ${pc.dim('Last used:')} ${new Date(wallet.lastUsed).toLocaleString()}`)
-    }
-    console.log('')
-  }
-
-  if (activeWallet) {
-    console.log(pc.dim(`Active wallet: ${activeWallet.name}`))
-  }
-
-  p.outro(pc.green(`Total: ${wallets.length} wallet(s)`))
-}
-```
-
-**After (reactive - 3 lines):**
-```typescript
-// commands/wallet/list.ts (NEW - Controller)
-import { renderScreen } from '../../ui/render.js'
-import { WalletListScreen } from '../../ui/screens/index.js'
-
-export async function listWallets() {
-  await renderScreen(WalletListScreen, {})
-}
-
-// ui/hooks/useWallet.ts (State Hook)
-export function useWallets() {
-  const [wallets, setWallets] = useState<Wallet[]>([])
-  const [activeWallet, setActiveWallet] = useState<Wallet | null>(null)
-  const [loading, setLoading] = useState(true)
-
-  useEffect(() => {
-    const walletStorage = getWalletStorage()
-    setWallets(walletStorage.getAllWallets())
-    setActiveWallet(walletStorage.getActiveWallet())
-    setLoading(false)
-  }, [])
-
-  return { wallets, activeWallet, loading }
-}
-
-// ui/screens/WalletListScreen.tsx (View)
-export function WalletListScreen({ onExit }) {
-  const { wallets, activeWallet, loading } = useWallets()
-
-  if (loading) return <Spinner message="Loading wallets..." />
-  if (wallets.length === 0) return <EmptyState />
-
-  return (
-    <Box flexDirection="column">
-      <Header title="Wallets" />
-      <List
-        items={wallets}
-        activeId={activeWallet?.id}
-        renderItem={(wallet, _, isActive) => (
-          <WalletItem wallet={wallet} isActive={isActive} />
-        )}
-      />
-      <Footer activeWallet={activeWallet} count={wallets.length} />
-    </Box>
-  )
-}
-```
-
-**Benefits Demonstrated:**
-- ✅ 93% reduction in command code (41 → 3 lines)
-- ✅ Complete separation: data (hooks) → logic (controller) → presentation (components)
-- ✅ Reusable components (List, Header, KeyValue)
-- ✅ Testable UI (can unit test WalletListScreen independently)
-- ✅ Type-safe throughout
-- ✅ Consistent styling via theme
-- ✅ Loading states with animated spinner
-- ✅ Empty state handling
-
-### 3.2 Create State Management Hooks ✅
-
-**Complete Hook Library Created:**
-
-All state management hooks have been implemented with consistent patterns:
-- Loading states with `useState(true)`
-- Error handling with error messages
-- Type-safe return values
-- Comprehensive JSDoc documentation with examples
-
-**Wallet Hooks** (`src/ui/hooks/useWallet.ts`):
-- ✅ `useWallets()` - Get all wallets + active wallet
-- ✅ `useWallet(walletId)` - Get specific wallet by ID
-
-**Safe Account Hooks** (`src/ui/hooks/useSafe.ts`):
-- ✅ `useSafes()` - Get all Safe accounts
-- ✅ `useSafe(chainId, address)` - Get specific Safe
-- ✅ `useSafesByChain(chainId)` - Get Safes filtered by chain
-- ✅ `useSafeExists(chainId, address)` - Check Safe existence
-
-**Configuration Hooks** (`src/ui/hooks/useConfig.ts`):
-- ✅ `useConfig()` - Get complete configuration
-- ✅ `useChains()` - Get all chain configurations
-- ✅ `useChain(chainId)` - Get specific chain config
-- ✅ `useDefaults()` - Get default settings
-- ✅ `usePreferences()` - Get user preferences
-- ✅ `useChainExists(chainId)` - Check chain existence
-
-**Transaction Hooks** (`src/ui/hooks/useTransaction.ts`):
-- ✅ `useTransactions()` - Get all transactions
-- ✅ `useTransaction(safeTxHash)` - Get specific transaction
-- ✅ `useTransactionsBySafe(address, chainId?)` - Get Safe transactions
-- ✅ `useTransactionsByStatus(status)` - Filter by status
-- ✅ `useTransactionStats()` - Get transaction statistics
-
-**Total:** 17 hooks covering all storage layers
-
----
-
-## Phase 4: Incremental Migration (Weeks 4-6)
-
-### 4.1 Migration Priority Order
-
-**Tier 1 - High Impact, Low Complexity (Week 4):**
-1. `cli.ts` - Welcome screen (14 console.log)
-2. `wallet/list.ts` - Wallet list (10 console.log)
-3. `account/list.ts` - Account list (21 console.log)
-4. `config/show.ts` - Config display (21 console.log)
-
-**Tier 2 - High Impact, Medium Complexity (Week 5):**
-5. `account/info.ts` - Account info (26 console.log)
-6. `account/deploy.ts` - Deployment confirmation (16 console.log)
-7. `tx/list.ts` - Transaction list (19 console.log)
-8. `config/init.ts` - Setup wizard (27 console.log)
-
-**Tier 3 - Complex Flows (Week 6):**
-9. `account/create.ts` - Creation flow (34 console.log)
-10. `account/remove-owner.ts` - Owner removal (25 console.log)
-11. `account/change-threshold.ts` - Threshold change (23 console.log)
-12. `tx/create.ts` - Transaction creation
-
-### 4.2 Migration Strategy Per File
-
-**For each file:**
-1. ✅ **Extract data fetching** to controller
-2. ✅ **Create screen component** in ui/screens/
-3. ✅ **Replace console.log** with renderScreen()
-4. ✅ **Add tests** for component
-5. ✅ **Update command** to use new rendering
-
----
-
-## Phase 5: Interactive Flows (Week 7)
-
-### 5.1 Integrate Interactive Prompts
-
-**Challenge:** Mixing @clack/prompts with Ink
-
-**Solution:** Create Ink-native prompt components or keep @clack for input
-
-**Option A - Keep @clack for input (recommended for faster migration):**
-```typescript
-// Pattern: Prompt → Data → Render
-const name = await p.text({ message: 'Safe name?' })
-const owners = await p.text({ message: 'Owners (comma-separated)?' })
-
-await renderScreen(AccountCreateSummaryScreen, {
-  name,
-  owners,
-  chain,
-})
-```
-
-**Option B - Full Ink migration (long-term goal):**
-```typescript
-// Use ink-text-input, ink-select-input
-<TextInput value={name} onChange={setName} />
-```
-
-### 5.2 Real-time Updates
-
-**Enable reactive features:**
-- Live transaction status updates
-- Blockchain confirmation polling
-- Multi-step wizards with progress
-- Animated spinners during async operations
-
----
-
-## Phase 6: Testing & Quality (Week 8)
-
-### 6.1 Component Testing
-```typescript
-// __tests__/AccountListScreen.test.tsx
-import { render } from 'ink-testing-library'
-
-test('renders account list', () => {
-  const { lastFrame } = render(
-    <AccountListScreen safes={mockSafes} />
-  )
-  expect(lastFrame()).toContain('Safe Accounts')
-})
-```
-
-### 6.2 Integration Testing
-- Test command → screen rendering
-- Verify data flow from services → screens
-- Test error states and edge cases
-
----
-
-## Key Benefits of Migration
-
-**Separation of Concerns:**
-- ✅ **Commands** = orchestration
-- ✅ **Services** = business logic
-- ✅ **Components** = presentation
-- ✅ **Hooks** = state management
-
-**Developer Experience:**
-- ✅ Reusable components (DRY principle)
-- ✅ Type-safe props with TypeScript
-- ✅ Testable UI components
-- ✅ Consistent styling via theme
-
-**User Experience:**
-- ✅ Smooth animations and transitions
-- ✅ Real-time updates (e.g., tx confirmations)
-- ✅ Better error handling UI
-- ✅ Professional, polished output
-
----
-
-## Risk Mitigation
-
-**Backward Compatibility:**
-- Migrate file-by-file
-- Keep old code until new version tested
-- Feature flags for gradual rollout
-
-**Testing Strategy:**
-- Visual regression testing (snapshot testing)
-- Manual QA for each migrated command
-- E2E tests for critical flows
-
-**Performance:**
-- Ink is fast but adds React overhead
-- Profile commands before/after
-- Optimize heavy renders (memoization)
-
----
-
-## Success Metrics
-
-- [ ] Zero direct console.log calls in command files
-- [ ] 100% of output through Ink components
-- [ ] <50ms render time for screens
-- [ ] 100% test coverage for UI components
-- [ ] Consistent styling across all commands
-
----
-
-## Implementation Status
-
-### Phase 1: Foundation & Infrastructure ✅
-- [x] Dependencies installed
-- [x] Directory structure created
-- [x] Render utility implemented
-- [x] Theme system implemented
-
-### Phase 2: Component Library ✅
-- [x] Table component (with column alignment, width calculation)
-- [x] List component (with active state, empty state, configurable spacing)
-- [x] KeyValue component (with auto-sizing, separators, indentation)
-- [x] Header component (with icons, subtitles)
-- [x] StatusBadge component (success/error/warning/info)
-- [x] Spinner component (animated loading states)
-- [x] WelcomeScreen proof-of-concept
-- [x] Component demo for testing
-
-### Phase 3: Logic/Presentation Separation ✅
-- [x] Complete state management hook library (17 hooks total)
-  - [x] Wallet hooks (2): useWallets, useWallet
-  - [x] Safe hooks (4): useSafes, useSafe, useSafesByChain, useSafeExists
-  - [x] Config hooks (6): useConfig, useChains, useChain, useDefaults, usePreferences, useChainExists
-  - [x] Transaction hooks (5): useTransactions, useTransaction, useTransactionsBySafe, useTransactionsByStatus, useTransactionStats
-- [x] Controller pattern implementation
-- [x] First complete migration: wallet list command
-  - Before: 41 lines of imperative console.log
-  - After: 3 lines calling renderScreen
-  - Demonstrates full controller → hooks → components flow
-- [x] All hooks have loading/error states and JSDoc documentation
-
-### Phase 4: Incremental Migration ⏳
-- [x] Tier 1 commands (Week 4) ✅
-  - [x] cli.ts - Welcome screen (14 lines → dynamic import)
-  - [x] wallet/list.ts - Wallet list (41 → 3 lines, 93% reduction)
-  - [x] account/list.ts - Account list (113 → 3 lines, 97% reduction)
-  - [x] config/show.ts - Config display (55 → 3 lines, 95% reduction)
-  - **All tested and working with reactive UI and live data fetching**
-- [x] Tier 2 commands (Week 5) ✅ - Complete!
-  - [x] account/info.ts - Account detail view (131 → 86 lines, 34% reduction in command)
-    - Created AccountInfoScreen with live on-chain data fetching
-    - Reactive loading states with animated spinners
-    - Shows Safe details, owners, threshold, balance for deployed Safes
-    - Displays predicted configuration for undeployed Safes
-    - Tested with Ethereum and Sepolia Safes successfully
-  - [x] tx/list.ts - Transaction list (177 → 127 lines, 28% reduction in command)
-    - Created TransactionListScreen with filtering and statistics
-    - Displays 10 transactions with status badges and detailed info
-    - Automatic sorting by date (newest first)
-    - Summary statistics by status (pending/signed/executed/rejected)
-    - Tested successfully showing 7 pending, 3 signed transactions
-  - [x] account/deploy.ts - Deployment flow (partial migration)
-    - Created AccountDeploySuccessScreen for deployment confirmation
-    - Migrated success display (lines 149-159 → renderScreen call)
-    - Kept interactive prompts for Safe selection and password input
-    - Shows deployed address, chain, and explorer link
-  - [x] config/init.ts - Configuration wizard (partial migration)
-    - Created ConfigInitSuccessScreen for completion message
-    - Migrated final success display (lines 151-160 → renderScreen call)
-    - Kept interactive prompts for chain setup and API key configuration
-    - Shows next steps with command examples
-  - **Complete Tier 2: 4/4 commands migrated!**
-- [x] Tier 3 commands (Week 6) ✅ - Complete!
-  - [x] account/create.ts - Safe creation flow (partial migration)
-    - Created AccountCreateSuccessScreen for success message display
-    - Migrated final success display (lines 187-207 → renderScreen call)
-    - Kept interactive prompts for user input (chains, owners, threshold, name)
-    - Pattern: Prompt → Data → Render (Interactive workflow + Ink output)
-    - Reduced success display from 21 lines of console.log to 5 lines with screen component
-  - [x] account/remove-owner.ts - Owner removal flow (partial migration)
-    - Created OwnerRemoveSuccessScreen for transaction creation confirmation
-    - Migrated final success display (lines 208-224 → renderScreen call)
-    - Shows transaction hash, Safe details (EIP-3770 format), and next steps
-    - Reduced success display from 17 lines of console.log to 7 lines with screen component
-  - [x] account/change-threshold.ts - Threshold change flow (partial migration)
-    - Created ThresholdChangeSuccessScreen for transaction creation confirmation
-    - Migrated final success display (lines 179-195 → renderScreen call)
-    - Shows old/new threshold values, transaction hash, and signing steps
-    - Reduced success display from 17 lines of console.log to 7 lines with screen component
-  - [x] tx/create.ts - Transaction creation flow (partial migration)
-    - Created TransactionCreateSuccessScreen for success message
-    - Migrated final success display (lines 398-407 → renderScreen call)
-    - Kept complex interactive flow for contract detection, ABI fetching, and builder
-    - Reduced success display from 10 lines of console.log to 4 lines with screen component
-  - **Note**: Complex interactive commands follow a hybrid approach:
-    - Keep @clack/prompts for interactive input flows
-    - Use Ink screens for result/summary displays
-    - This provides best UX for both input and output
-  - **Complete Tier 3: 4/4 commands migrated!**
-- [x] Tier 4 commands (Additional Priority Commands) ⏳ - In Progress
-  - [x] Wallet commands (3/3) ✅
-    - wallet/import.ts - Wallet import success display
-      - Created WalletImportSuccessScreen
-      - Migrated success display (lines 83-89 → renderScreen call)
-      - Shows wallet name, address, and shortened address
-    - wallet/use.ts - Active wallet switch confirmation
-      - Created WalletUseSuccessScreen
-      - Migrated success display (lines 40-45 → renderScreen call)
-      - Shows new active wallet details
-    - wallet/remove.ts - Wallet removal confirmation
-      - Created WalletRemoveSuccessScreen
-      - Migrated success display (lines 55-57 → renderScreen call)
-      - Confirms wallet deletion
-  - [x] Account commands (2/2) ✅
-    - account/open.ts - Open existing Safe flow
-      - Created SafeOpenSuccessScreen
-      - Migrated success display (lines 110-114 → renderScreen call)
-      - Confirms Safe added to workspace
-    - account/add-owner.ts - Add owner transaction flow
-      - Created OwnerAddSuccessScreen
-      - Migrated success display (lines 217-232 → renderScreen call)
-      - Shows transaction hash, Safe details, next steps
-      - Similar pattern to remove-owner and change-threshold
-  - [x] Transaction commands (2/8) - Partial ✅
-    - tx/sign.ts - Transaction signing flow
-      - Created TransactionSignSuccessScreen
-      - Migrated success display (lines 183-198 → renderScreen call)
-      - Shows signature progress (X/Y required)
-      - Displays execution command when ready
-    - tx/execute.ts - Transaction execution flow
-      - Created TransactionExecuteSuccessScreen
-      - Migrated final success display (p.outro → renderScreen)
-      - Shows blockchain tx hash and explorer link
-  - [x] Transaction commands (7/8) ✅
-    - tx/sign.ts - Transaction signing flow
-    - tx/execute.ts - Transaction execution flow
-    - tx/status.ts - Transaction status details (67 console.log)
-      - Created TransactionStatusScreen
-      - Comprehensive status display with signature progress
-    - tx/export.ts - Export to JSON
-      - Created TransactionExportSuccessScreen
-    - tx/pull.ts - Pull from Safe API (15 console.log)
-      - Created TransactionPullSuccessScreen
-      - Shows imported/updated/skipped transactions with summary
-    - tx/push.ts - Push to Safe API (23 console.log)
-      - Created TransactionPushSuccessScreen
-      - Displays proposed/updated status with signer list
-    - tx/sync.ts - Two-way sync with API (19 console.log)
-      - Created TransactionSyncSuccessScreen
-      - Shows pull/push statistics with directional indicators
-  - [x] Config commands (4/4) ✅
-    - config/chains.ts - Chain management (add/list/remove)
-      - Created ChainListScreen, ChainAddSuccessScreen, ChainRemoveSuccessScreen
-    - config/edit.ts - Interactive JSON editor
-      - Created ChainEditSuccessScreen showing added/modified/removed chains
-  - [x] Transaction commands (8/8) ✅ - COMPLETE!
-    - tx/sign.ts, tx/execute.ts, tx/status.ts, tx/export.ts
-    - tx/pull.ts, tx/push.ts, tx/sync.ts
-    - tx/import.ts - Import from JSON/Transaction Builder (93 console.log)
-      - Created TransactionImportBuilderSuccessScreen for Transaction Builder format
-      - Created TransactionImportSuccessScreen for CLI format (both new and merged)
-      - Handles two import paths: batch transactions and individual imports
-      - Shows appropriate next steps based on signature status
-  - **Tier 4 Progress: 17/17 commands migrated** ✅ COMPLETE!
-    - Wallet commands (3/3): import, use, remove
-    - Account commands (2/2): open, add-owner
-    - Transaction commands (8/8): sign, execute, status, export, pull, push, sync, import
-    - Config commands (4/4): chains (add/list/remove/edit)
-
-### Phase 5: Interactive Flows ⏳
-- [ ] Prompt integration strategy
-- [ ] Real-time updates
-
-### Phase 6: Testing & Quality ⏳
-- [ ] Component tests
-- [ ] Integration tests
-- [ ] E2E tests
-
----
-
-## Migration Results Summary
-
-### Commands Migrated: 29/29 (100%) ✅ 🎉 COMPLETE!
-
-**✅ All Commands Migrated (29):**
-- **Tier 1 (4)**: cli.ts, wallet/list.ts, account/list.ts, config/show.ts
-- **Tier 2 (4)**: account/info.ts, tx/list.ts, account/deploy.ts, config/init.ts
-- **Tier 3 (4)**: account/create.ts, account/remove-owner.ts, account/change-threshold.ts, tx/create.ts
-- **Tier 4 (17)**:
-  - Wallet (3): wallet/import.ts, wallet/use.ts, wallet/remove.ts
-  - Account (2): account/open.ts, account/add-owner.ts
-  - Transaction (8): tx/sign.ts, tx/execute.ts, tx/status.ts, tx/export.ts, tx/pull.ts, tx/push.ts, tx/sync.ts, tx/import.ts
-  - Config (4): config/chains.ts (add/list/remove), config/edit.ts
-
-**Migration Status: 🎉 ALL COMMANDS MIGRATED! 🎉**
-
-### Architecture Created
-
-**Components (7 reusable):**
-- Table, List, KeyValue, Header, StatusBadge, Spinner, Layout
-
-**Hooks (17 state management):**
-- Wallet: useWallets, useWallet
-- Safe: useSafes, useSafe, useSafesByChain, useSafeExists
-- Config: useConfig, useChains, useChain, useDefaults, usePreferences, useChainExists
-- Transaction: useTransactions, useTransaction, useTransactionsBySafe, useTransactionsByStatus, useTransactionStats
-
-**Screens (31 full-page views):**
-- Welcome, WalletList, WalletImportSuccess, WalletUseSuccess, WalletRemoveSuccess
-- AccountList, AccountInfo, AccountCreateSuccess, AccountDeploySuccess, SafeOpenSuccess, OwnerAddSuccess, OwnerRemoveSuccess, ThresholdChangeSuccess
-- ConfigShow, ConfigInitSuccess, ChainList, ChainAddSuccess, ChainRemoveSuccess, ChainEditSuccess
-- TransactionList, TransactionCreateSuccess, TransactionSignSuccess, TransactionExecuteSuccess, TransactionStatus, TransactionExportSuccess, TransactionPullSuccess, TransactionPushSuccess, TransactionSyncSuccess, TransactionImportBuilderSuccess, TransactionImportSuccess
-
-### Code Reduction
-
-**Total console.log statements removed: 670+**
-- tx/pull.ts: 15 console.log removed
-- tx/push.ts: 23 console.log removed
-- tx/sync.ts: 19 console.log removed
-- tx/import.ts: 93 console.log removed (most complex command)
-- **Total in this session: 150 console.log removed**
-- Simple displays: 90-97% reduction (complete replacement)
-- Detail views: 28-34% reduction (screen + live data)
-- Interactive flows: Partial migration (success displays only)
-- Config commands: 100% migration (15 console.log → screens)
-
-### Benefits Achieved
-
-1. **Separation of Concerns**: Commands orchestrate, components present
-2. **Reusability**: Shared components reduce duplication
-3. **Type Safety**: Full TypeScript props validation
-4. **Reactive Updates**: Live data fetching without screen clearing
-5. **Consistency**: Uniform styling across all commands
-6. **Maintainability**: Clear architecture patterns
-
-### Patterns Established
-
-**Pattern A - Simple Display (Complete Replacement):**
-```typescript
-// Command → Screen
-await renderScreen(Screen, { data })
-```
-
-**Pattern B - Detail View (Live Data):**
-```typescript
-// Screen fetches live data via hooks
-const { data, loading, error } = useHook()
-```
-
-**Pattern C - Interactive Flow (Hybrid):**
-```typescript
-// Prompts for input → Screen for output
-const input = await p.text({ ... })
-await renderScreen(SuccessScreen, { result })
-```
-
----
-
-## 🎉 MIGRATION COMPLETE! 🎉
-
-### Final Achievement Summary
-
-**100% Migration Complete - All 29 Commands Migrated**
-
-Starting from 561+ console.log statements across the CLI, we have successfully completed the migration to a modern React/Ink-based UI architecture.
-
-### What We Built
-
-✅ **31 Screen Components** - Full-page views with consistent styling
-✅ **17 State Management Hooks** - With loading/error states  
-✅ **7 Reusable UI Components** - Table, List, KeyValue, Header, StatusBadge, Spinner, Layout
-✅ **3 Clear Patterns** - Simple displays, detail views, interactive flows
-
-### Impact
-
-📊 **670+ console.log statements removed**
-🎯 **100% of commands migrated** (29/29)
-🏗️ **Clean architecture** - Commands → Screens → Hooks → Storage
-⚡ **Reactive UI** - Live data fetching with animated loading states
-🔒 **Type safety** - Full TypeScript prop validation
-
-### This Session's Work
-
-In this final session, we migrated the last 4 complex API commands:
-
-1. **tx/pull.ts** (15 console.log) - Pull transactions from Safe API
-2. **tx/push.ts** (23 console.log) - Push transactions to Safe API  
-3. **tx/sync.ts** (19 console.log) - Two-way sync with Safe API
-4. **tx/import.ts** (93 console.log) - Import from JSON/Transaction Builder
-
-**Total this session: 150 console.log removed**
-
-The tx/import.ts command was the most complex, handling two distinct import formats (Transaction Builder and CLI format) with batch transaction support and signature merging.
-
-### Technical Wins
-
-1. **Reactive UI**: Components fetch live blockchain data with loading states
-2. **Separation of Concerns**: Clear boundaries between command logic and presentation
-3. **Reusability**: Shared components eliminate code duplication
-4. **Consistency**: Unified styling and theming across all commands
-5. **Maintainability**: Established patterns for future development
-
-### Migration is Complete!
-
-All CLI commands now use the modern Ink-based UI architecture. The codebase is ready for:
-- Testing (component tests, integration tests, E2E tests)
-- Performance optimization
-- Additional interactive features
-- UI component library documentation
-
-**Mission accomplished! 🚀**
diff --git a/PROJECT_PLAN.md b/PROJECT_PLAN.md
deleted file mode 100644
index dac7182..0000000
--- a/PROJECT_PLAN.md
+++ /dev/null
@@ -1,898 +0,0 @@
-# Safe CLI - Comprehensive Project Plan
-
-## 1. Project Overview
-
-### Goals
-- Create an intuitive CLI for Safe Smart Account management
-- Abstract complexity of multi-sig operations and Ethereum transactions
-- Support both interactive TUI and non-interactive (scriptable) modes
-- Enable custom chain and deployment configurations
-- Provide guided workflows for Safe operations
-
-### Key Differentiators
-- Modern, beautiful TUI with real-time feedback
-- Progressive disclosure of complexity
-- Built-in educational prompts and explanations
-- Transaction simulation and validation before execution
-- State persistence for multi-session workflows
-
----
-
-## 2. Architecture & Technology Stack
-
-### Core Technologies
-
-**CLI Framework:**
-- **Commander.js** or **Yargs** - Command parsing and routing
-- **Inquirer.js** or **@clack/prompts** - Interactive prompts (modern, beautiful UI)
-- **Ora** - Elegant terminal spinners
-- **Chalk** - Terminal colors
-- **Boxen** - Styled boxes for important info
-
-**Alternative Modern Stack:**
-- **@clack/prompts** - Next-gen interactive CLI (recommended)
-- **picocolors** - Fast, tiny color library
-- **tsx** - TypeScript execution
-
-**SDK Integration:**
-- `@safe-global/protocol-kit` - Core SDK
-- `@safe-global/types-kit` - Type definitions
-- `viem` - Ethereum utilities (already used by protocol-kit)
-
-**State Management:**
-- **Conf** - Persistent config storage
-- **Keytar** or **keychain** - Secure credential storage (OS keychain)
-- Alternative: Encrypted JSON files with `crypto` module
-
-**Additional Utilities:**
-- **zod** - Runtime validation & type safety
-- **execa** - Process execution for external tools
-- **update-notifier** - CLI update notifications
-
----
-
-## 3. Core Feature Modules
-
-### Module 1: Configuration Management
-```
-safe config init          # Initialize CLI configuration
-safe config chains        # Manage chain configurations
-safe config deployments   # Manage custom Safe deployments
-safe config show          # Display current configuration
-safe config reset         # Reset to defaults
-```
-
-**Features:**
-- Store custom RPC endpoints per chain
-- Custom Safe contract deployments
-- Default Safe version preference
-- Gas strategy preferences
-- Analytics/telemetry opt-in/out
-
-**Storage Schema:**
-```typescript
-{
-  version: string,
-  chains: {
-    [chainId]: {
-      name: string,
-      rpcUrl: string,
-      explorer: string,
-      currency: string,
-      contractNetworks?: ContractNetworksConfig
-    }
-  },
-  defaults: {
-    safeVersion: SafeVersion,
-    signingMethod: SigningMethod,
-    gasStrategy: 'fast' | 'medium' | 'slow'
-  },
-  preferences: {
-    analytics: boolean,
-    autoUpdate: boolean
-  }
-}
-```
-
----
-
-### Module 2: Wallet/Signer Management
-```
-safe wallet import        # Import private key (secure prompt)
-safe wallet use          # Switch active wallet
-safe wallet list         # List imported wallets
-safe wallet remove       # Remove wallet
-safe wallet balance      # Check balances across chains
-```
-
-**Features:**
-- Secure keychain integration (OS-level)
-- Support for multiple signers
-- Passkey support (future)
-- Read-only mode (no signer required)
-- Display addresses with ENS resolution
-
-**Security:**
-- Never log private keys
-- Use OS keychain when available
-- Fallback to encrypted storage
-- Require password/PIN for sensitive operations
-- Clear guidance on key management
-
----
-
-### Module 3: Safe Account Management
-```
-safe account create      # Create new Safe account
-safe account deploy      # Deploy predicted Safe
-safe account open        # Open existing Safe (add to workspace)
-safe account list        # List all Safe accounts in workspace
-safe account info        # Display Safe details
-safe account switch      # Switch active Safe
-safe account export      # Export Safe configuration
-```
-
-**Create Flow (Interactive):**
-1. Select chain (from configured chains)
-2. Choose Safe version or use default
-3. Add owners (multiple entries, ENS support)
-4. Set threshold (with validation)
-5. Optional: Add modules/guards/fallback handler
-6. Preview configuration
-7. Choose: Deploy now / Save as predicted
-8. Show predicted address
-9. If deploying: estimate gas, confirm, execute
-
-**Open Flow:**
-1. Enter Safe address (with validation)
-2. Detect chain (or specify)
-3. Fetch Safe info (owners, threshold, modules)
-4. Display Safe state
-5. Add to workspace with friendly name
-
-**Account Storage:**
-```typescript
-{
-  safes: {
-    [safeId]: {
-      name: string,
-      address: string,
-      chainId: string,
-      version: SafeVersion,
-      owners: string[],
-      threshold: number,
-      deployed: boolean,
-      predictedConfig?: PredictedSafeProps,
-      createdAt: string,
-      lastUsed: string
-    }
-  },
-  activeSafe: safeId | null
-}
-```
-
----
-
-### Module 4: Owner & Threshold Management
-```
-safe owners list         # List current owners
-safe owners add          # Add owner (with threshold update)
-safe owners remove       # Remove owner
-safe owners replace      # Swap owner
-safe threshold set       # Change threshold
-```
-
-**Interactive Flow:**
-- Display current owners with addresses/ENS
-- Validate threshold rules (1 ≤ threshold ≤ owners)
-- Create transaction for approval
-- Guide through multi-sig signing if needed
-- Track pending owner changes
-
----
-
-### Module 5: Transaction Creation & Management
-```
-safe tx create           # Create new transaction
-safe tx batch            # Create batch transaction
-safe tx template         # Use transaction template
-safe tx list             # List pending transactions
-safe tx show <id>        # Show transaction details
-safe tx sign <id>        # Sign pending transaction
-safe tx execute <id>     # Execute transaction
-safe tx simulate <id>    # Simulate transaction
-safe tx cancel <id>      # Cancel/reject transaction
-```
-
-**Transaction Builder (Interactive):**
-1. **Simple Mode:**
-   - Send ETH: Recipient + amount
-   - Call contract: Address + ABI/function selector + params
-   - Use template: Token transfer, NFT transfer, etc.
-
-2. **Advanced Mode:**
-   - Multiple transactions (batch)
-   - Raw calldata input
-   - DelegateCall operations
-   - Custom gas parameters
-   - Nonce management
-
-3. **Transaction Preview:**
-   ```
-   ┌─ Transaction Summary ─────────────────────┐
-   │ To:       0x742d...8976                   │
-   │ Value:    0.5 ETH                         │
-   │ Data:     0x                              │
-   │ Type:     CALL                            │
-   │ Gas:      21000                           │
-   │                                           │
-   │ Signers:  1 / 2                          │
-   │ ✓ 0x123...456 (you)                      │
-   │ ○ 0x789...012                            │
-   └───────────────────────────────────────────┘
-   ```
-
-4. **Simulation:**
-   - Run `isValidTransaction()`
-   - Show state changes (using trace/debug)
-   - Display warnings (balance checks, gas estimates)
-
-5. **Signing:**
-   - Select signing method (EIP-712 v4 default)
-   - Sign with active wallet
-   - Show signature added
-   - Export for other signers if needed
-
-6. **Execution:**
-   - Verify threshold met
-   - Final confirmation prompt
-   - Execute with spinner/progress
-   - Show transaction hash + explorer link
-   - Wait for confirmation
-   - Display result
-
-**Transaction Storage:**
-```typescript
-{
-  transactions: {
-    [txId]: {
-      safeAddress: string,
-      chainId: string,
-      txData: SafeTransactionData,
-      signatures: Map<string, SafeSignature>,
-      status: 'pending' | 'signed' | 'executed' | 'failed',
-      createdAt: string,
-      executedAt?: string,
-      txHash?: string,
-      metadata: {
-        description?: string,
-        tags?: string[]
-      }
-    }
-  }
-}
-```
-
----
-
-### Module 6: Transaction Templates
-```
-safe template list       # List available templates
-safe template use        # Use a template
-safe template create     # Create custom template
-```
-
-**Built-in Templates:**
-- **ERC20 Transfer**: Token transfers with decimal handling
-- **ERC721 Transfer**: NFT transfers
-- **ERC1155 Transfer**: Multi-token transfers
-- **Contract Deployment**: Deploy contracts via Safe
-- **Gnosis Safe Upgrade**: Upgrade Safe implementation
-- **Module Management**: Enable/disable modules
-- **Guard Management**: Set/remove guards
-
-**Template Structure:**
-```typescript
-{
-  name: string,
-  description: string,
-  category: string,
-  inputs: {
-    name: string,
-    type: 'address' | 'uint256' | 'string' | ...,
-    description: string,
-    validation?: (value: any) => boolean
-  }[],
-  buildTransaction: (inputs: any) => MetaTransactionData
-}
-```
-
----
-
-### Module 7: Module & Guard Management
-```
-safe modules list        # List enabled modules
-safe modules enable      # Enable module
-safe modules disable     # Disable module
-
-safe guards show         # Show current guard
-safe guards set          # Set guard
-safe guards remove       # Remove guard
-
-safe fallback show       # Show fallback handler
-safe fallback set        # Set fallback handler
-```
-
----
-
-### Module 8: Multi-Sig Coordination
-```
-safe share tx <id>       # Export transaction for sharing
-safe import tx           # Import transaction from file/string
-safe sync                # Sync with Safe Transaction Service (future)
-```
-
-**Sharing Flow:**
-1. Export transaction as JSON or base64
-2. Share via file, clipboard, or QR code
-3. Other owner imports
-4. Other owner signs
-5. Combine signatures
-6. Execute when threshold met
-
-**Future: Safe Transaction Service Integration**
-- Auto-sync pending transactions
-- Off-chain signature collection
-- Transaction history
-
----
-
-## 4. Implementation Phases
-
-### Phase 1: Foundation (Week 1-2)
-- [ ] Project setup (TypeScript, build config, dependencies)
-- [ ] CLI structure with Commander/Clack
-- [ ] Configuration management (chains, storage)
-- [ ] Wallet import/management (secure storage)
-- [ ] Basic Safe SDK initialization
-
-**Deliverable:** `safe config` and `safe wallet` commands working
-
----
-
-### Phase 2: Safe Account Operations (Week 3-4)
-- [ ] Safe account creation (interactive flow)
-- [ ] Safe account deployment
-- [ ] Safe account opening (existing)
-- [ ] Account information display
-- [ ] Workspace management
-
-**Deliverable:** `safe account` commands working, can create and deploy Safes
-
----
-
-### Phase 3: Transaction Core (Week 5-6)
-- [ ] Simple transaction creation (ETH transfer)
-- [ ] Transaction signing
-- [ ] Transaction execution
-- [ ] Transaction simulation/validation
-- [ ] Transaction storage and listing
-
-**Deliverable:** Basic `safe tx` flow working end-to-end
-
----
-
-### Phase 4: Advanced Transactions (Week 7-8)
-- [ ] Batch transactions (MultiSend)
-- [ ] ABI integration for contract calls
-- [ ] Transaction templates system
-- [ ] Built-in templates (ERC20, ERC721, etc.)
-- [ ] Gas estimation and optimization
-
-**Deliverable:** Complete transaction builder with templates
-
----
-
-### Phase 5: Multi-Sig & Coordination (Week 9-10)
-- [ ] Transaction export/import
-- [ ] Signature collection workflow
-- [ ] Owner management (add/remove/swap)
-- [ ] Threshold changes
-- [ ] Multi-owner scenarios
-
-**Deliverable:** Full multi-sig workflow supported
-
----
-
-### Phase 6: Advanced Features (Week 11-12)
-- [ ] Module management
-- [ ] Guard management
-- [ ] Fallback handler management
-- [ ] Custom deployment configurations
-- [ ] Chain management
-
-**Deliverable:** Complete feature set
-
----
-
-### Phase 7: Polish & Distribution (Week 13-14)
-- [ ] Comprehensive error handling
-- [ ] Help documentation
-- [ ] Examples and tutorials
-- [ ] npm package setup
-- [ ] CI/CD for releases
-- [ ] Update notifier
-- [ ] Analytics (opt-in)
-
-**Deliverable:** Production-ready CLI
-
----
-
-## 5. Project Structure
-
-```
-safe-cli/
-├── src/
-│   ├── index.ts                    # CLI entry point
-│   ├── cli.ts                      # Command definitions
-│   │
-│   ├── commands/                   # Command handlers
-│   │   ├── config/
-│   │   │   ├── init.ts
-│   │   │   ├── chains.ts
-│   │   │   ├── deployments.ts
-│   │   │   └── show.ts
-│   │   ├── wallet/
-│   │   │   ├── import.ts
-│   │   │   ├── list.ts
-│   │   │   ├── use.ts
-│   │   │   └── remove.ts
-│   │   ├── account/
-│   │   │   ├── create.ts
-│   │   │   ├── deploy.ts
-│   │   │   ├── open.ts
-│   │   │   ├── list.ts
-│   │   │   └── info.ts
-│   │   ├── transaction/
-│   │   │   ├── create.ts
-│   │   │   ├── batch.ts
-│   │   │   ├── sign.ts
-│   │   │   ├── execute.ts
-│   │   │   ├── simulate.ts
-│   │   │   └── list.ts
-│   │   ├── owners/
-│   │   ├── modules/
-│   │   ├── guards/
-│   │   └── template/
-│   │
-│   ├── services/                   # Business logic
-│   │   ├── safe-service.ts         # Safe SDK operations
-│   │   ├── transaction-service.ts   # Transaction management
-│   │   ├── signer-service.ts       # Wallet/signer management
-│   │   ├── config-service.ts       # Configuration management
-│   │   └── template-service.ts     # Template management
-│   │
-│   ├── storage/                    # Persistence
-│   │   ├── config-store.ts         # Configuration storage
-│   │   ├── wallet-store.ts         # Secure wallet storage
-│   │   ├── safe-store.ts           # Safe accounts storage
-│   │   └── tx-store.ts             # Transaction storage
-│   │
-│   ├── ui/                         # UI components
-│   │   ├── prompts.ts              # Reusable prompts
-│   │   ├── formatters.ts           # Output formatting
-│   │   ├── tables.ts               # Table displays
-│   │   ├── spinners.ts             # Loading indicators
-│   │   └── messages.ts             # Success/error messages
-│   │
-│   ├── utils/                      # Utilities
-│   │   ├── validation.ts           # Input validation
-│   │   ├── ethereum.ts             # Ethereum utilities
-│   │   ├── encoding.ts             # Data encoding/decoding
-│   │   ├── abi.ts                  # ABI handling
-│   │   └── errors.ts               # Error handling
-│   │
-│   ├── templates/                  # Transaction templates
-│   │   ├── index.ts                # Template registry
-│   │   ├── erc20-transfer.ts
-│   │   ├── erc721-transfer.ts
-│   │   ├── contract-deployment.ts
-│   │   └── custom-templates/       # User templates
-│   │
-│   ├── types/                      # TypeScript types
-│   │   ├── config.ts
-│   │   ├── wallet.ts
-│   │   ├── transaction.ts
-│   │   └── template.ts
-│   │
-│   └── constants/                  # Constants
-│       ├── chains.ts               # Common chain configs
-│       ├── contracts.ts            # Well-known contracts
-│       └── defaults.ts
-│
-├── tests/
-│   ├── unit/
-│   ├── integration/
-│   └── e2e/
-│
-├── templates/                      # Built-in templates
-│   └── ... (JSON/YAML definitions)
-│
-├── docs/
-│   ├── README.md
-│   ├── GETTING_STARTED.md
-│   ├── COMMANDS.md
-│   ├── TEMPLATES.md
-│   └── EXAMPLES.md
-│
-├── package.json
-├── tsconfig.json
-├── .eslintrc.js
-└── .prettierrc
-```
-
----
-
-## 6. User Experience Flows
-
-### First-Time Setup Flow
-```bash
-$ safe
-
-👋 Welcome to Safe CLI!
-
-It looks like this is your first time using Safe CLI.
-Let's get you set up!
-
-? Do you want to import a wallet now? › Yes
-? Enter your private key: ******************************
-? Give this wallet a name: main-wallet
-✓ Wallet imported successfully!
-
-? Select chains to configure:
-  ✓ Ethereum Mainnet (default RPC)
-  ✓ Polygon
-  ○ Arbitrum
-  ○ Enter custom chain
-
-✓ Configuration saved!
-
-Next steps:
-  • Create a Safe:  safe account create
-  • Open a Safe:    safe account open
-  • View help:      safe help
-```
-
----
-
-### Creating a Safe (Interactive)
-```bash
-$ safe account create
-
-🔐 Create Safe Account
-
-? Select chain: ›
-  Ethereum Mainnet (1)
-> Polygon (137)
-  Arbitrum One (42161)
-
-? Safe version: › 1.4.1 (recommended)
-
-👥 Configure Owners
-
-? Owner 1 address: 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbD
-✓ Valid address
-
-? Add another owner? › Yes
-
-? Owner 2 address: vitalik.eth
-⏳ Resolving ENS...
-✓ Resolved to 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045
-
-? Add another owner? › No
-
-⚙️ Configure Threshold
-
-? Signature threshold (1-2): › 2
-
-? Add modules/guards/fallback handler? › No
-
-📋 Safe Configuration Summary
-
-  Chain:      Polygon (137)
-  Version:    1.4.1
-  Owners:     2
-              • 0x742d...bEbD (you)
-              • 0xd8dA...6045 (vitalik.eth)
-  Threshold:  2 / 2
-
-  Predicted Address: 0x1234567890abcdef1234567890abcdef12345678
-
-? What would you like to do? ›
-> Deploy now
-  Save as predicted (deploy later)
-  Cancel
-
-⏳ Deploying Safe...
-
-  • Estimating gas...    21,234 gas (~$0.05)
-  • Creating deployment transaction...
-  • Sending transaction... 0xabcd...
-  • Waiting for confirmation...
-
-✓ Safe deployed successfully!
-
-  Safe Address:    0x1234567890abcdef1234567890abcdef12345678
-  Transaction:     0xabcd1234...
-  Block:           #42,123,456
-  Gas Used:        21,234 (~$0.05)
-
-  View on explorer: https://polygonscan.com/address/0x1234...
-
-Safe added to workspace as: my-polygon-safe
-```
-
----
-
-### Creating a Transaction (Interactive)
-```bash
-$ safe tx create
-
-💸 Create Transaction
-
-Current Safe: my-polygon-safe (0x1234...5678)
-Chain: Polygon (137)
-Balance: 10.5 MATIC
-
-? Transaction type: ›
-  Send ETH/Native Token
-> Call Contract Function
-  Use Template
-  Advanced (Raw Data)
-
-? Contract address: 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174
-⏳ Loading contract info...
-✓ USDC Token (ERC20)
-
-? Select function: ›
-> transfer(address recipient, uint256 amount)
-  approve(address spender, uint256 amount)
-  transferFrom(address sender, address recipient, uint256 amount)
-
-? Recipient address: 0x9876543210abcdef9876543210abcdef98765432
-✓ Valid address
-
-? Amount: 100
-? Decimals: › 6 (detected: USDC uses 6 decimals)
-✓ Amount: 100.000000 USDC
-
-📋 Transaction Summary
-
-  To:         USDC Token (0x2791...4174)
-  Function:   transfer
-  Parameters:
-    recipient: 0x9876...5432
-    amount:    100000000 (100.000000 USDC)
-  Value:      0 MATIC
-  Operation:  CALL
-
-? Add another transaction (batch)? › No
-
-⏳ Simulating transaction...
-✓ Transaction simulation successful!
-
-  Estimated Gas: 65,000
-  Gas Cost: ~$0.02
-
-  State Changes:
-  • Your Safe USDC balance: 1,000.00 → 900.00 (-100.00)
-  • 0x9876...5432 USDC balance: 50.00 → 150.00 (+100.00)
-
-? Proceed? ›
-> Sign & Save
-  Save without signing
-  Cancel
-
-⏳ Signing transaction...
-✓ Signed! (1 / 2 signatures)
-
-Transaction ID: tx_abc123
-
-? Next steps: ›
-  Wait for other signers
-> Export for other signers
-  View transaction details
-
-? Export format: ›
-> Copy to clipboard
-  Save to file
-  Show QR code
-
-✓ Transaction copied to clipboard!
-
-Share this with other signers:
-safe import tx <paste>
-
-Once 2/2 signatures collected, execute with:
-safe tx execute tx_abc123
-```
-
----
-
-### Non-Interactive Mode
-```bash
-# Create Safe
-safe account create \
-  --chain 137 \
-  --owners 0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbD,vitalik.eth \
-  --threshold 2 \
-  --deploy \
-  --name my-polygon-safe
-
-# Create transaction
-safe tx create \
-  --to 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174 \
-  --value 0 \
-  --data $(cast calldata "transfer(address,uint256)" 0x9876... 100000000) \
-  --output tx_abc123.json
-
-# Sign transaction
-safe tx sign tx_abc123 --key-file key.json
-
-# Execute transaction
-safe tx execute tx_abc123 --yes
-```
-
----
-
-## 7. Configuration Management
-
-### Config File Location
-- **macOS**: `~/.config/safe-cli/config.json`
-- **Linux**: `~/.config/safe-cli/config.json`
-- **Windows**: `%APPDATA%\safe-cli\config.json`
-
-### Secure Storage
-- **macOS**: Keychain
-- **Linux**: gnome-keyring / secret-service
-- **Windows**: Credential Manager
-- **Fallback**: Encrypted JSON with user password
-
-### Environment Variables
-```bash
-SAFE_CLI_RPC_URL          # Override default RPC
-SAFE_CLI_PRIVATE_KEY      # Provide signer (for scripts)
-SAFE_CLI_CONFIG_DIR       # Override config directory
-SAFE_CLI_NO_ANALYTICS     # Disable analytics
-SAFE_CLI_CHAIN_ID         # Default chain
-```
-
----
-
-## 8. Security Considerations
-
-### Private Key Handling
-- ✓ Never log private keys
-- ✓ Use OS keychain when available
-- ✓ Encrypt fallback storage
-- ✓ Clear memory after use
-- ✓ Warn users about key management
-- ✓ Support read-only mode (no keys needed)
-
-### Transaction Safety
-- ✓ Always simulate before execution
-- ✓ Display clear transaction summaries
-- ✓ Require explicit confirmation
-- ✓ Validate addresses (checksum)
-- ✓ Warn on large value transfers
-- ✓ Show gas estimates
-
-### Network Safety
-- ✓ Validate RPC URLs
-- ✓ Warn on custom deployments
-- ✓ Verify chain IDs
-- ✓ Support for Tenderly/Foundry forking
-
----
-
-## 9. Testing Strategy
-
-### Unit Tests
-- Service layer logic
-- Validation functions
-- Encoding/decoding utilities
-- Template rendering
-
-### Integration Tests
-- Safe SDK integration
-- Storage operations
-- End-to-end command flows
-
-### E2E Tests
-- Full user workflows
-- Use local testnet (Hardhat/Anvil)
-- Test multi-sig scenarios
-- Test error handling
-
-### Manual Testing Checklist
-- [ ] First-time setup flow
-- [ ] All interactive prompts
-- [ ] Non-interactive mode
-- [ ] Error messages are helpful
-- [ ] Cross-platform (macOS, Linux, Windows)
-
----
-
-## 10. Distribution & Deployment
-
-### NPM Package
-```json
-{
-  "name": "@safe-global/safe-cli",
-  "version": "1.0.0",
-  "bin": {
-    "safe": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts",
-    "prepublish": "npm run build"
-  }
-}
-```
-
-### Installation
-```bash
-npm install -g @safe-global/safe-cli
-
-# or
-
-npx @safe-global/safe-cli
-```
-
-### CI/CD
-- GitHub Actions for testing
-- Semantic versioning
-- Automated releases
-- Changelog generation
-
-### Documentation
-- Comprehensive README
-- Command reference
-- Tutorial videos
-- Example scripts
-
----
-
-## 11. Future Enhancements
-
-### Phase 8+
-- Safe Transaction Service integration
-- Passkey support
-- Hardware wallet support (Ledger, Trezor)
-- Account abstraction features (EIP-4337)
-- Safe Apps integration
-- Webhook/notification system
-- Dashboard/web UI companion
-- Plugin system for custom commands
-- Team/organization management
-- Transaction scheduling
-- Governance tools (Snapshot integration)
-
----
-
-## 12. Success Metrics
-
-- **Usability**: User completes first Safe creation in < 2 minutes
-- **Reliability**: 99% success rate for valid operations
-- **Performance**: Commands respond in < 500ms (excluding blockchain ops)
-- **Adoption**: Target 1000 active users in first 3 months
-- **Satisfaction**: > 4.5/5 user rating
-
----
-
-## Next Steps
-
-1. Review and refine this plan based on feedback
-2. Set up project infrastructure (Phase 1)
-3. Begin implementation following the phased approach
-4. Iterate based on user testing and feedback
diff --git a/README.md b/README.md
index 2bdb9bc..673acba 100644
--- a/README.md
+++ b/README.md
@@ -1,354 +1,296 @@
 # Safe CLI
 
-Modern, interactive CLI for Safe Smart Account management. Built on top of the [Safe Core SDK](https://github.com/safe-global/safe-core-sdk).
+> A modern, interactive command-line tool for managing Safe Smart Accounts
+
+Built on top of the [Safe Core SDK](https://github.com/safe-global/safe-core-sdk), Safe CLI makes it easy to create, manage, and interact with Safe multi-signature wallets directly from your terminal.
 
 [![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/5afe/safe-cli-nodejs?view=terminal&hideNavigation=1&hideDevTools=1&terminalHeight=100)
 
-## Features
+---
+
+## Why Safe CLI?
+
+Safe CLI provides a powerful command-line interface for:
+- **Creating and managing Safe accounts** without using the web interface
+- **Coordinating multi-signature transactions** with your team
+- **Interacting with smart contracts** through an intuitive transaction builder
+- **Automating Safe operations** in scripts and workflows
+- **Managing multiple Safes across different chains** from one place
+
+Perfect for developers, power users, and teams who prefer working in the terminal.
+
+---
 
-- 🔐 Secure wallet management with encrypted storage
-- ⛓️ Multi-chain support with customizable configurations
-- 🎨 Beautiful, modern TUI with interactive prompts
-- 🚀 Both interactive and non-interactive modes
-- 📦 Safe account creation, deployment, and management
-- 📝 Transaction creation, signing, and execution
-- 🔄 Multi-sig coordination workflows
-- 🤖 Smart contract interaction with automatic ABI fetching
-- 🔌 Proxy contract support (EIP-1967)
-- 👥 Owner management (add/remove owners, change threshold)
-- 📥 Transaction Builder JSON import with auto-detection
+## ✨ Features
 
-## Installation
+### Core Functionality
+- 🔐 **Secure wallet management** - Encrypted private key storage with AES-256-GCM
+- ⛓️ **Multi-chain support** - Works with Ethereum, Polygon, Arbitrum, Optimism, Base, and more
+- 🎨 **Beautiful interface** - Modern terminal UI with interactive prompts
+- 📦 **Safe lifecycle** - Create, deploy, and manage Safe accounts
+- 📝 **Transaction handling** - Create, sign, and execute transactions
+
+### Advanced Features
+- 🤖 **Smart contract interaction** - Automatic ABI fetching and interactive function builder
+- 🔌 **Proxy support** - Detects and handles EIP-1967 proxy contracts
+- 👥 **Owner management** - Add/remove owners and change thresholds
+- 🔄 **Multi-sig coordination** - Multiple workflows for collecting signatures
+- 📥 **Transaction import** - Import from Safe web app's Transaction Builder
+
+---
+
+## 🚀 Quick Start
+
+### Installation
 
 ```bash
+# Install globally
 npm install -g @safe-global/safe-cli
 
-# Or use without installing
+# Or run without installing
 npx @safe-global/safe-cli
 ```
 
-## Quick Start
-
-### 1. Initialize Configuration
+### First-Time Setup
 
+**1. Initialize configuration**
 ```bash
 safe config init
 ```
+This sets up your chain configurations and optional API keys.
 
-This will set up default chain configurations and preferences.
-
-### 2. Import a Wallet
-
+**2. Import a wallet**
 ```bash
 safe wallet import
 ```
+Your private key will be encrypted with a password you choose.
 
-Your private key will be encrypted and stored securely.
-
-### 3. View Configuration
-
+**3. Create your first Safe**
 ```bash
-safe config show
+safe account create
 ```
+Follow the interactive prompts to configure owners and threshold.
 
-## Commands
+**That's it!** You're ready to manage Safe accounts from your terminal.
 
-### Configuration Management
+---
 
-```bash
-safe config init              # Initialize CLI configuration (includes API key setup)
-safe config show              # Display current configuration (shows API key status)
-safe config chains list       # List configured chains
-safe config chains add        # Add a custom chain
-safe config chains remove     # Remove a chain
-safe config chains edit       # Edit chains in text editor (power users)
-```
+## 📚 Command Reference
 
-### Wallet Management
+### Configuration
 
-```bash
-safe wallet import            # Import a wallet with private key
-safe wallet list              # List all wallets
-safe wallet use               # Switch active wallet
-safe wallet remove            # Remove a wallet
-```
+| Command | Description |
+|---------|-------------|
+| `safe config init` | Set up CLI for first use (includes API keys) |
+| `safe config show` | View current configuration |
+| `safe config chains list` | List configured networks |
+| `safe config chains add` | Add a custom network |
+| `safe config chains remove` | Remove a network |
+| `safe config chains edit` | Edit chains in your text editor |
 
-### Safe Account Operations
+### Wallets
 
-```bash
-safe account create                   # Create new Safe account
-safe account deploy [account]         # Deploy predicted Safe (EIP-3770 format)
-safe account open [address]           # Open existing Safe (EIP-3770 format or bare address)
-safe account list                     # List all Safe accounts
-safe account info [account]           # Show Safe details (EIP-3770 format)
-safe account add-owner [account]      # Add a new owner to a Safe
-safe account remove-owner [account]   # Remove an owner from a Safe
-safe account change-threshold [account]  # Change signature threshold
-```
+| Command | Description |
+|---------|-------------|
+| `safe wallet import` | Import a wallet with your private key |
+| `safe wallet list` | View all your wallets |
+| `safe wallet use` | Switch to a different wallet |
+| `safe wallet remove` | Delete a wallet |
 
-**EIP-3770 Address Format:**
-Safe addresses use the [EIP-3770](https://eips.ethereum.org/EIPS/eip-3770) standard format: `shortName:address`
+### Safe Accounts
 
-Examples:
-- `eth:0x742d35Cc6634C0532925a3b844Bc454e4438f44e` (Ethereum)
-- `sep:0x1405b9b5A42D07bD1D625B1DCcd5EF29Ee5a3f15` (Sepolia)
-- `matic:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` (Polygon)
+| Command | Description |
+|---------|-------------|
+| `safe account create` | Create a new Safe |
+| `safe account deploy [address]` | Deploy a predicted Safe to the blockchain |
+| `safe account open [address]` | Add an existing Safe to your workspace |
+| `safe account list` | View all your Safes |
+| `safe account info [address]` | Show Safe details (owners, threshold, balance) |
+| `safe account add-owner [address]` | Add a new owner |
+| `safe account remove-owner [address]` | Remove an owner |
+| `safe account change-threshold [address]` | Change signature threshold |
 
-This makes it clear which chain a Safe belongs to. Commands will interactively prompt for Safe selection when needed.
+**💡 Tip:** Most commands support EIP-3770 format (`eth:0x123...`) or will prompt you interactively.
 
-**Opening an Existing Safe:**
+### Transactions
 
-The `account open` command supports three usage modes:
+| Command | Description |
+|---------|-------------|
+| `safe tx create` | Create a new transaction |
+| `safe tx sign [txHash]` | Sign a transaction |
+| `safe tx execute [txHash]` | Execute a transaction |
+| `safe tx list` | View transactions |
+| `safe tx status [txHash]` | Check signature progress |
+| `safe tx export [txHash]` | Export as JSON for sharing |
+| `safe tx import [json]` | Import from JSON |
 
-1. **EIP-3770 format** - Provide both chain and address in one argument:
-   ```bash
-   safe account open sep:0x742d35Cc6634C0532925a3b844Bc454e4438f44e
-   ```
+**Multi-sig Coordination:**
 
-2. **Bare address** - Provide just the address, CLI will ask for chain:
-   ```bash
-   safe account open 0x742d35Cc6634C0532925a3b844Bc454e4438f44e
-   # → Prompts for chain selection
-   ```
+| Command | Description |
+|---------|-------------|
+| `safe tx push [txHash]` | Upload to Safe Transaction Service |
+| `safe tx pull` | Download pending transactions |
+| `safe tx sync` | Sync local and remote transactions |
 
-3. **Interactive** - No arguments, CLI asks for both chain and address:
-   ```bash
-   safe account open
-   # → Prompts for chain and address
-   ```
+---
 
-### Transaction Management
+## 💡 Common Workflows
 
-```bash
-safe tx create                 # Create transaction (interactive contract builder for contracts)
-safe tx sign [safeTxHash]      # Sign transaction (use Safe TX Hash)
-safe tx execute [safeTxHash]   # Execute transaction (use Safe TX Hash)
-safe tx list [account]         # List transactions (interactively filter by Safe or show all)
-safe tx status [safeTxHash]    # Show transaction status and signature progress
-safe tx export [safeTxHash]    # Export transaction as JSON for sharing
-safe tx export [safeTxHash] -o file  # Export to file
-safe tx import [json]          # Import transaction from JSON string or file
-safe tx push [safeTxHash]      # Push transaction to Safe Transaction Service
-safe tx pull [account]         # Pull transactions from Safe Transaction Service
-safe tx sync [account]         # Sync transactions (push local + pull remote)
-```
+### Creating and Deploying a Safe
 
-**Transaction Builder - Smart Contract Interactions:**
+```bash
+# 1. Create a Safe (gets predicted address)
+safe account create
 
-When creating a transaction to a contract address, the CLI automatically:
-1. Detects if the address is a contract
-2. Fetches the contract ABI from Etherscan or Sourcify
-3. Detects and handles EIP-1967 proxy contracts (merges proxy + implementation ABIs)
-4. Offers an interactive function selector with all writable functions
-5. Prompts for each parameter with type validation
-6. Automatically encodes the function call
+# 2. Send some ETH to the predicted address for deployment gas
 
-Example flow:
-```bash
-$ safe tx create
-
-# Enter contract address
-To address: 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
-
-✓ Contract detected
-✓ Proxy detected! Implementation: 0x43506849...
-✓ Contract ABI found!
-✓ Implementation ABI found!
-✓ Found 15 writable function(s)
-
-# Interactive builder
-? Use transaction builder to interact with contract? Yes
-? Select function to call:
-  ❯ transfer(address _to, uint256 _value)
-    approve(address _spender, uint256 _value)
-    transferFrom(address _from, address _to, uint256 _value)
-    ...
-
-# Parameter input with validation
-? _to (address): 0x742d35Cc...
-? _value (uint256): 1000000  # 1 USDC
-
-✓ Transaction created successfully!
+# 3. Deploy it to the blockchain
+safe account deploy eth:0x742d35Cc...
 ```
 
-**Multi-sig Coordination Workflows:**
+### Sending ETH from a Safe
 
-*Option 1: Using Safe Transaction Service (Recommended)*
 ```bash
-# Owner A: Create, sign, and push to Safe API
+# Create and sign a transaction
 safe tx create
-safe tx sign <safeTxHash>
-safe tx push <safeTxHash>
+# → Select your Safe
+# → Enter recipient address
+# → Enter amount in wei
+# → Sign it
 
-# Owner B: Pull and sign
-safe tx pull                 # Fetch pending transactions
-safe tx sign <safeTxHash>
-safe tx push <safeTxHash>    # Push signature back
+# If you're the only signer needed, execute immediately
+safe tx execute <txHash>
 
-# Or sync everything at once
-safe tx sync                 # Pull + push in one command
-
-# Execute when threshold reached
-safe tx execute <safeTxHash>
+# Or, share the transaction with other signers (see Multi-sig section)
 ```
 
-*Option 2: Using JSON Export/Import (Offline)*
+### Interacting with a Smart Contract
+
 ```bash
-# Owner A: Create and sign transaction
 safe tx create
-safe tx sign <safeTxHash>
-safe tx export <safeTxHash>  # Copy the JSON output
-
-# Owner B: Import and sign
-safe tx import '{"safeTxHash":"0x..."...}'
-safe tx sign <safeTxHash>
+# → Select your Safe
+# → Enter contract address
 
-# Check progress
-safe tx status <safeTxHash>  # Shows: "2/3 signatures collected"
+# The CLI automatically:
+# ✓ Detects it's a contract
+# ✓ Fetches the ABI from Etherscan/Sourcify
+# ✓ Shows you all available functions
+# ✓ Helps you fill in parameters with validation
+# ✓ Encodes the transaction
 
-# Execute when threshold reached
-safe tx execute <safeTxHash>
+# Then sign and execute as usual
 ```
 
-*Option 3: Import from Safe Transaction Builder*
-```bash
-# Import transaction batch from Safe web app (https://app.safe.global)
-# The CLI will auto-detect the Transaction Builder JSON format
-safe tx import transaction-builder.json
+### Multi-sig Coordination
 
-# Or paste the JSON directly
-safe tx import '{"version":"1.0","chainId":"1",...}'
+**Option A: Using Safe Transaction Service** (Recommended)
 
-# Each transaction will prompt for:
-# - Nonce (suggested based on current Safe state)
-# - Gas parameters (optional)
-
-# Then sign and execute as usual
-safe tx sign <safeTxHash>
-safe tx execute <safeTxHash>
-```
+```bash
+# Owner 1: Create and push
+safe tx create
+safe tx sign <txHash>
+safe tx push <txHash>
 
-**Transaction Builder Format Support:**
+# Owner 2: Pull and sign
+safe tx pull
+safe tx sign <txHash>
+safe tx push <txHash>
 
-The CLI can import transaction batches from the Safe Transaction Builder (web app). This allows you to:
-- Create complex transaction batches in the web UI
-- Export as JSON from the Transaction Builder
-- Import into the CLI for signing and execution
-- Missing fields (nonce, gas parameters) will be configured during import
+# Any owner: Execute when threshold is met
+safe tx execute <txHash>
+```
 
-**Note:** Transaction Builder batches with multiple transactions will be imported as separate transactions. Native batch support via MultiSend is planned for a future release.
+**Option B: Offline with JSON Export**
 
-## Configuration
+```bash
+# Owner 1: Create and export
+safe tx create
+safe tx sign <txHash>
+safe tx export <txHash>
+# → Share the JSON with other owners
 
-Configuration files are stored in:
-- **macOS**: `~/.config/safe-cli/`
-- **Linux**: `~/.config/safe-cli/`
-- **Windows**: `%APPDATA%\safe-cli\`
+# Owner 2: Import and sign
+safe tx import '{"safeTxHash":"0x..."...}'
+safe tx sign <txHash>
 
-### Optional API Keys
+# Check progress
+safe tx status <txHash>  # Shows "2/3 signatures"
 
-The CLI supports two optional API keys that enhance functionality:
+# Execute when ready
+safe tx execute <txHash>
+```
 
-#### Safe Transaction Service API Key (Optional)
+---
 
-The Safe Transaction Service requires an API key. You can get one from [Safe Dashboard](https://developer.safe.global).
+## ⚙️ Configuration
 
-**Benefits:**
-- Push transactions to Safe Transaction Service (`safe tx push`)
-- Pull pending transactions from the service (`safe tx pull`)
-- Bidirectional sync (`safe tx sync`)
-- Multi-sig coordination via the Safe web interface
+### Storage Location
 
-**Without this key:** You can still use the offline JSON export/import workflow for multi-sig coordination.
+Configuration files are stored in:
+- **macOS/Linux**: `~/.config/safe-cli/`
+- **Windows**: `%APPDATA%\safe-cli\`
 
-#### Etherscan API Key (Optional)
+### Supported Networks (Default)
 
-An API key for Etherscan enables enhanced contract interaction features. Get a free key from [Etherscan](https://etherscan.io/myapikey).
+- Ethereum Mainnet
+- Sepolia Testnet
+- Polygon
+- Arbitrum One
+- Optimism
+- Base
+- Gnosis Chain
+- BNB Smart Chain
+- Avalanche C-Chain
 
-**Benefits:**
-- Automatic proxy contract detection (EIP-1967)
-- Better ABI fetching with implementation contract support
-- Automatic merging of proxy + implementation ABIs for proxy contracts
+Add custom networks with `safe config chains add`.
 
-**Without this key:** The CLI falls back to Sourcify (free, no API key required) for ABI fetching, but proxy contract detection will not work.
+### Optional API Keys
 
-#### Configuring API Keys
+These are optional but recommended for enhanced functionality:
 
-**During initial setup:**
-```bash
-safe config init
-# You'll be prompted for both API keys
-```
+#### Safe Transaction Service API Key
 
-**To view configured keys:**
-```bash
-safe config show
-# Shows obfuscated API keys (first 8 + last 4 characters)
-```
+**Get it from:** [Safe Developer Dashboard](https://developer.safe.global)
 
-**To add or update keys later:**
-Edit your configuration file directly or run `safe config init` again.
+**Enables:**
+- Multi-sig coordination via Safe Transaction Service
+- Push/pull transactions
+- Integration with Safe web interface
 
-### Supported Chains (Default)
+**Without it:** You can still use offline JSON export/import for multi-sig.
 
-- Ethereum Mainnet (1)
-- Sepolia (11155111)
-- Polygon (137)
-- Arbitrum One (42161)
-- Optimism (10)
-- Base (8453)
-- Gnosis Chain (100)
+#### Etherscan API Key
 
-You can add custom chains using `safe config chains add`.
+**Get it from:** [Etherscan](https://etherscan.io/myapikey) (free)
 
-### Editing Chains in Text Editor
+**Enables:**
+- Proxy contract detection (EIP-1967)
+- Better ABI fetching for proxies
+- Automatic ABI merging for proxy + implementation
 
-For power users, you can edit all chain configurations at once in your preferred text editor:
+**Without it:** Uses Sourcify as fallback (still works, but no proxy detection).
 
-```bash
-safe config chains edit
-```
+**Setup:** Run `safe config init` and follow the prompts, or edit the config file manually.
 
-This command:
-- Opens your chains configuration in `$EDITOR` (vim, nano, VS Code, etc.)
-- Validates JSON structure on save
-- Shows a diff of changes before applying
-- Supports adding, modifying, and removing multiple chains at once
-
-The configuration format:
-
-```json
-{
-  "chains": {
-    "1": {
-      "chainId": "1",
-      "name": "Ethereum",
-      "shortName": "eth",
-      "rpcUrl": "https://eth.llamarpc.com",
-      "currency": "ETH",
-      "explorer": "https://etherscan.io"
-    }
-  }
-}
-```
+---
 
-The `shortName` field is used for [EIP-3770](https://eips.ethereum.org/EIPS/eip-3770) address formatting.
+## 🔐 Security
 
-## Security
+- **Encryption**: Private keys encrypted with AES-256-GCM
+- **Key derivation**: PBKDF2 with 100,000 iterations
+- **Local storage**: All data stored locally on your machine
+- **No exposure**: Keys never logged or transmitted in plain text
 
-- Private keys are encrypted using AES-256-GCM
-- Password-based key derivation with PBKDF2 (100,000 iterations)
-- Keys never logged or exposed in plain text
-- Support for OS keychain integration (planned)
+---
 
-## Development
+## 🛠️ For Developers
 
 ### Prerequisites
 
 - Node.js >= 18.0.0
 - npm or yarn
 
-### Setup
+### Development Setup
 
 ```bash
 # Clone the repository
@@ -361,96 +303,82 @@ npm install
 # Run in development mode
 npm run dev
 
+# Type checking
+npm run typecheck
+
+# Run tests
+npm test
+
 # Build
 npm run build
-
-# Run built version
-npm start
 ```
 
 ### Project Structure
 
 ```
 src/
-├── commands/          # Command handlers
-│   ├── config/       # Configuration commands
-│   └── wallet/       # Wallet commands
-├── storage/          # Persistence layer
+├── commands/           # Command implementations
+│   ├── config/        # Configuration commands
+│   ├── wallet/        # Wallet management
+│   ├── account/       # Safe account operations
+│   └── tx/            # Transaction commands
+├── services/          # Business logic
+│   ├── safe-service.ts
+│   ├── transaction-service.ts
+│   ├── abi-service.ts
+│   └── validation-service.ts
+├── storage/           # Persistent storage
 │   ├── config-store.ts
-│   └── wallet-store.ts
-├── types/            # TypeScript types
-├── utils/            # Utility functions
-├── ui/               # UI components
-├── constants/        # Constants and defaults
-├── cli.ts            # Command definitions
-└── index.ts          # Entry point
+│   ├── wallet-store.ts
+│   └── transaction-store.ts
+├── ui/                # Terminal UI components (React/Ink)
+├── types/             # TypeScript type definitions
+└── utils/             # Utility functions
 ```
 
-## Roadmap
-
-### ✅ Phase 1: Foundation (Complete)
-- [x] Project setup
-- [x] Configuration management
-- [x] Wallet import/management
-- [x] Secure storage
-
-### ✅ Phase 2: Safe Account Operations (Complete)
-- [x] Safe account creation
-- [x] Safe deployment
-- [x] Account management
-
-### ✅ Phase 3: Transaction Core (Complete)
-- [x] Transaction creation with editable nonce
-- [x] Transaction signing
-- [x] Transaction execution
-- [x] Multi-sig workflow support
-- [x] safeTxHash as transaction identifier
-
-### ✅ Phase 4: Owner Management (Complete)
-- [x] Add owners to Safe
-- [x] Remove owners from Safe
-- [x] Change signature threshold
-- [x] Live on-chain data fetching
-
-### ✅ Phase 5: Multi-sig Coordination (Complete)
-- [x] Transaction status display
-- [x] Export/import transactions as JSON
-- [x] Signature tracking and progress
-- [x] Share transactions via JSON for multi-sig
-
-### ✅ Phase 6: Smart Contract Interactions (Complete)
-- [x] Automatic contract detection
-- [x] ABI fetching from Etherscan and Sourcify
-- [x] EIP-1967 proxy contract support
-- [x] Interactive transaction builder
-- [x] Function selector with parameter validation
-- [x] Automatic function encoding
-- [x] Display contract names
-
-### ✅ Phase 7: Safe Transaction Service Integration (Complete)
-- [x] Push transactions to Safe Transaction Service
-- [x] Pull transactions from Safe Transaction Service
-- [x] Sync transactions (push + pull)
-- [x] Automatic signature merging
-- [x] Multi-chain support for Transaction Service
-
-### 📅 Phase 8+: Advanced Features
-- [ ] Batch transactions
-- [ ] Transaction templates
-- [ ] Module & guard management
-- [ ] Recovery and social recovery flows
-- [ ] Hardware wallets support
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
+### Tech Stack
 
-MIT
+- **TypeScript** - Type safety
+- **Commander.js** - CLI framework
+- **React + Ink** - Terminal UI
+- **@clack/prompts** - Interactive prompts
+- **Viem** - Ethereum utilities
+- **Safe Core SDK** - Safe protocol integration
+- **Zod** - Runtime validation
 
-## Links
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Make your changes
+4. Run tests (`npm test`)
+5. Commit with a clear message
+6. Push and open a Pull Request
+
+Please ensure:
+- Tests pass (`npm test`)
+- TypeScript compiles (`npm run typecheck`)
+- Code is formatted (`npm run format`)
+
+---
+
+## 📖 Additional Resources
 
-- [Safe Core SDK](https://github.com/safe-global/safe-core-sdk)
 - [Safe Documentation](https://docs.safe.global/)
+- [Safe Core SDK](https://github.com/safe-global/safe-core-sdk)
 - [Safe Website](https://safe.global/)
+- [EIP-3770: Chain-specific addresses](https://eips.ethereum.org/EIPS/eip-3770)
+
+---
+
+## 📄 License
+
+MIT
+
+---
+
+Made with ❤️ for the Safe community
diff --git a/src/commands/account/create.ts b/src/commands/account/create.ts
index 6f1d1a5..369ca24 100644
--- a/src/commands/account/create.ts
+++ b/src/commands/account/create.ts
@@ -4,7 +4,7 @@ import { getConfigStore } from '../../storage/config-store.js'
 import { getSafeStorage } from '../../storage/safe-store.js'
 import { getWalletStorage } from '../../storage/wallet-store.js'
 import { SafeService } from '../../services/safe-service.js'
-import { isValidAddress } from '../../utils/validation.js'
+import { getValidationService } from '../../services/validation-service.js'
 import { checksumAddress, shortenAddress } from '../../utils/ethereum.js'
 import { formatSafeAddress } from '../../utils/eip3770.js'
 import { logError } from '../../ui/messages.js'
@@ -67,6 +67,8 @@ export async function createSafe() {
 
   // Add more owners
   let addingOwners = true
+  const validator = getValidationService()
+
   while (addingOwners) {
     const addMore = await p.confirm({
       message: `Add ${owners.length > 0 ? 'another' : 'an'} owner?`,
@@ -87,9 +89,9 @@ export async function createSafe() {
       message: 'Owner address:',
       placeholder: '0x...',
       validate: (value) => {
-        if (!value) return 'Address is required'
-        if (!isValidAddress(value)) return 'Invalid Ethereum address'
-        const checksummed = checksumAddress(value)
+        const addressError = validator.validateAddress(value)
+        if (addressError) return addressError
+        const checksummed = checksumAddress(value as string)
         if (owners.includes(checksummed as Address)) return 'Owner already added'
         return undefined
       },
@@ -114,14 +116,7 @@ export async function createSafe() {
   const threshold = await p.text({
     message: `Signature threshold (1-${owners.length}):`,
     placeholder: Math.min(2, owners.length).toString(),
-    validate: (value) => {
-      if (!value) return 'Threshold is required'
-      const num = parseInt(value, 10)
-      if (isNaN(num)) return 'Must be a number'
-      if (num < 1) return 'Threshold must be at least 1'
-      if (num > owners.length) return `Threshold cannot exceed ${owners.length} owners`
-      return undefined
-    },
+    validate: (value) => validator.validateThreshold(value, 1, owners.length),
   })
 
   if (p.isCancel(threshold)) {
@@ -135,7 +130,7 @@ export async function createSafe() {
   const name = await p.text({
     message: 'Give this Safe a name:',
     placeholder: 'my-safe',
-    validate: (value) => (!value ? 'Name is required' : undefined),
+    validate: (value) => validator.validateRequired(value, 'Name'),
   })
 
   if (p.isCancel(name)) {
diff --git a/src/commands/config/chains.ts b/src/commands/config/chains.ts
index f7548ce..94410e1 100644
--- a/src/commands/config/chains.ts
+++ b/src/commands/config/chains.ts
@@ -1,7 +1,7 @@
 import * as p from '@clack/prompts'
 import { getConfigStore } from '../../storage/config-store.js'
 import type { ChainConfig } from '../../types/config.js'
-import { isValidChainId, isValidUrl } from '../../utils/validation.js'
+import { getValidationService } from '../../services/validation-service.js'
 import { logError } from '../../ui/messages.js'
 import { renderScreen } from '../../ui/render.js'
 import {
@@ -14,14 +14,15 @@ export async function addChain() {
   p.intro('Add Chain')
 
   const configStore = getConfigStore()
+  const validator = getValidationService()
 
   const chainId = await p.text({
     message: 'Chain ID:',
     placeholder: '1',
     validate: (value) => {
-      if (!value) return 'Chain ID is required'
-      if (!isValidChainId(value)) return 'Invalid chain ID'
-      if (configStore.chainExists(value)) return `Chain ${value} already exists`
+      const error = validator.validateChainId(value)
+      if (error) return error
+      if (configStore.chainExists(value as string)) return `Chain ${value} already exists`
       return undefined
     },
   })
@@ -34,7 +35,7 @@ export async function addChain() {
   const name = await p.text({
     message: 'Chain name:',
     placeholder: 'Ethereum Mainnet',
-    validate: (value) => (!value ? 'Chain name is required' : undefined),
+    validate: (value) => validator.validateRequired(value, 'Chain name'),
   })
 
   if (p.isCancel(name)) {
@@ -45,12 +46,7 @@ export async function addChain() {
   const shortName = await p.text({
     message: 'Short name (EIP-3770):',
     placeholder: 'eth',
-    validate: (value) => {
-      if (!value) return 'Short name is required'
-      if (!/^[a-z0-9-]+$/.test(value))
-        return 'Short name must be lowercase alphanumeric with hyphens'
-      return undefined
-    },
+    validate: (value) => validator.validateShortName(value),
   })
 
   if (p.isCancel(shortName)) {
@@ -61,11 +57,7 @@ export async function addChain() {
   const rpcUrl = await p.text({
     message: 'RPC URL:',
     placeholder: 'https://eth.llamarpc.com',
-    validate: (value) => {
-      if (!value) return 'RPC URL is required'
-      if (!isValidUrl(value)) return 'Invalid URL'
-      return undefined
-    },
+    validate: (value) => validator.validateUrl(value, true),
   })
 
   if (p.isCancel(rpcUrl)) {
@@ -86,7 +78,7 @@ export async function addChain() {
   const currency = await p.text({
     message: 'Native currency symbol:',
     placeholder: 'ETH',
-    validate: (value) => (!value ? 'Currency symbol is required' : undefined),
+    validate: (value) => validator.validateRequired(value, 'Currency symbol'),
   })
 
   if (p.isCancel(currency)) {
@@ -97,10 +89,7 @@ export async function addChain() {
   const transactionServiceUrl = await p.text({
     message: 'Safe Transaction Service URL (optional):',
     placeholder: 'https://safe-transaction-mainnet.safe.global',
-    validate: (value) => {
-      if (value && !isValidUrl(value)) return 'Invalid URL'
-      return undefined
-    },
+    validate: (value) => validator.validateUrl(value, false),
   })
 
   if (p.isCancel(transactionServiceUrl)) {
diff --git a/src/commands/config/edit.ts b/src/commands/config/edit.ts
index 6291229..b24cbbb 100644
--- a/src/commands/config/edit.ts
+++ b/src/commands/config/edit.ts
@@ -7,6 +7,7 @@ import { getConfigStore } from '../../storage/config-store.js'
 import { SafeCLIError } from '../../utils/errors.js'
 import { renderScreen } from '../../ui/render.js'
 import { ChainEditSuccessScreen } from '../../ui/screens/index.js'
+import type { ChainConfig } from '../../types/config.js'
 
 export async function editChains() {
   p.intro('Edit Chain Configurations')
@@ -66,10 +67,10 @@ export async function editChains() {
     unlinkSync(tempFile) // Clean up temp file
 
     // Parse and validate
-    let parsedConfig: any
+    let parsedConfig: { chains?: Record<string, unknown> }
     try {
       parsedConfig = JSON.parse(editedContent)
-    } catch (error) {
+    } catch {
       throw new SafeCLIError('Invalid JSON format. Changes not saved.')
     }
 
@@ -81,7 +82,7 @@ export async function editChains() {
 
     // Validate each chain
     for (const [chainId, chain] of Object.entries(newChains)) {
-      const c = chain as any
+      const c = chain as ChainConfig
 
       if (!c.chainId || !c.name || !c.shortName || !c.rpcUrl || !c.currency) {
         throw new SafeCLIError(
@@ -135,9 +136,9 @@ export async function editChains() {
       (id) => oldChainIds.has(id) && JSON.stringify(chains[id]) !== JSON.stringify(newChains[id])
     )
 
-    const addedNames = added.map((id) => newChains[id].name)
+    const addedNames = added.map((id) => (newChains[id] as ChainConfig).name)
     const removedNames = removed.map((id) => chains[id].name)
-    const modifiedNames = modified.map((id) => newChains[id].name)
+    const modifiedNames = modified.map((id) => (newChains[id] as ChainConfig).name)
 
     const confirm = await p.confirm({
       message: 'Apply these changes?',
@@ -160,7 +161,7 @@ export async function editChains() {
 
     // Add/update chains
     for (const [chainId, chain] of Object.entries(newChains)) {
-      const c = chain as any
+      const c = chain as ChainConfig
       configStore.setChain(chainId, {
         chainId: c.chainId,
         name: c.name,
diff --git a/src/commands/tx/create.ts b/src/commands/tx/create.ts
index 6cd4212..6a0125f 100644
--- a/src/commands/tx/create.ts
+++ b/src/commands/tx/create.ts
@@ -1,16 +1,16 @@
 import * as p from '@clack/prompts'
-import { isAddress, type Address } from 'viem'
+import { type Address } from 'viem'
 import { getConfigStore } from '../../storage/config-store.js'
 import { getSafeStorage } from '../../storage/safe-store.js'
 import { getTransactionStore } from '../../storage/transaction-store.js'
 import { getWalletStorage } from '../../storage/wallet-store.js'
 import { TransactionService } from '../../services/transaction-service.js'
 import { ContractService } from '../../services/contract-service.js'
-import { ABIService } from '../../services/abi-service.js'
+import { ABIService, type ABI, type ABIFunction } from '../../services/abi-service.js'
 import { TransactionBuilder } from '../../services/transaction-builder.js'
+import { getValidationService } from '../../services/validation-service.js'
 import { SafeCLIError } from '../../utils/errors.js'
 import { formatSafeAddress } from '../../utils/eip3770.js'
-import { validateAndChecksumAddress } from '../../utils/validation.js'
 import { renderScreen } from '../../ui/render.js'
 import { TransactionCreateSuccessScreen } from '../../ui/screens/index.js'
 
@@ -22,6 +22,7 @@ export async function createTransaction() {
     const configStore = getConfigStore()
     const walletStorage = getWalletStorage()
     const transactionStore = getTransactionStore()
+    const validator = getValidationService()
 
     const activeWallet = walletStorage.getActiveWallet()
     if (!activeWallet) {
@@ -105,11 +106,7 @@ export async function createTransaction() {
     const toInput = await p.text({
       message: 'To address',
       placeholder: '0x...',
-      validate: (value) => {
-        if (!value) return 'Address is required'
-        if (!isAddress(value)) return 'Invalid Ethereum address'
-        return undefined
-      },
+      validate: (value) => validator.validateAddress(value),
     })
 
     if (p.isCancel(toInput)) {
@@ -117,15 +114,8 @@ export async function createTransaction() {
       return
     }
 
-    // Checksum the address immediately
-    let to: Address
-    try {
-      to = validateAndChecksumAddress(toInput as string)
-    } catch (error) {
-      p.log.error(error instanceof Error ? error.message : 'Invalid address')
-      p.outro('Failed')
-      return
-    }
+    // Checksum the address
+    const to = validator.assertAddress(toInput as string, 'To address')
 
     // Check if address is a contract
     const contractService = new ContractService(chain)
@@ -139,7 +129,7 @@ export async function createTransaction() {
     try {
       isContract = await contractService.isContract(to)
       spinner2.stop(isContract ? 'Contract detected' : 'EOA (regular address)')
-    } catch (error) {
+    } catch {
       spinner2.stop('Failed to check contract')
       p.log.warning('Could not determine if address is a contract, falling back to manual input')
     }
@@ -159,7 +149,7 @@ export async function createTransaction() {
       }
 
       const abiService = new ABIService(chain, etherscanApiKey)
-      let abi: any = null
+      let abi: ABI | null = null
       let contractName: string | undefined
 
       try {
@@ -203,17 +193,15 @@ export async function createTransaction() {
             // Filter out duplicates by function signature
             const combinedAbi = [...implAbi]
             const existingSignatures = new Set(
-              implAbi
-                .filter((item: any) => item.type === 'function')
-                .map(
-                  (item: any) =>
-                    `${item.name}(${item.inputs?.map((i: any) => i.type).join(',') || ''})`
-                )
+              (implAbi.filter((item) => item.type === 'function') as ABIFunction[]).map(
+                (item) => `${item.name}(${item.inputs?.map((i) => i.type).join(',') || ''})`
+              )
             )
 
             for (const item of abi) {
               if (item.type === 'function') {
-                const sig = `${item.name}(${item.inputs?.map((i: any) => i.type).join(',') || ''})`
+                const funcItem = item as ABIFunction
+                const sig = `${funcItem.name}(${funcItem.inputs?.map((i) => i.type).join(',') || ''})`
                 if (!existingSignatures.has(sig)) {
                   combinedAbi.push(item)
                 }
@@ -225,14 +213,14 @@ export async function createTransaction() {
 
             abi = combinedAbi
             console.log(`  Combined: ${abi.length} items total`)
-          } catch (error) {
+          } catch {
             console.log('⚠ Could not fetch implementation ABI, using proxy ABI only')
             console.log(`  Found ${abi.length} items in proxy ABI`)
           }
         } else {
           console.log(`  Found ${abi.length} items in ABI`)
         }
-      } catch (error) {
+      } catch {
         console.log('⚠ Could not fetch ABI')
         console.log('  Contract may not be verified. Falling back to manual input.')
       }
@@ -261,7 +249,7 @@ export async function createTransaction() {
             const selectedFuncSig = await p.select({
               message: 'Select function to call:',
               options: functions.map((func) => {
-                const signature = `${func.name}(${func.inputs?.map((i: any) => i.type).join(',') || ''})`
+                const signature = `${func.name}(${func.inputs?.map((i) => i.type).join(',') || ''})`
                 return {
                   value: signature,
                   label: abiService.formatFunctionSignature(func),
@@ -277,7 +265,7 @@ export async function createTransaction() {
             }
 
             const func = functions.find((f) => {
-              const sig = `${f.name}(${f.inputs?.map((i: any) => i.type).join(',') || ''})`
+              const sig = `${f.name}(${f.inputs?.map((i) => i.type).join(',') || ''})`
               return sig === selectedFuncSig
             })
             if (!func) {
@@ -307,15 +295,7 @@ export async function createTransaction() {
         message: 'Value in wei (0 for token transfer)',
         placeholder: '0',
         initialValue: '0',
-        validate: (val) => {
-          if (!val) return 'Value is required'
-          try {
-            BigInt(val)
-            return undefined
-          } catch {
-            return 'Invalid number'
-          }
-        },
+        validate: (val) => validator.validateWeiValue(val),
       })) as string
 
       if (p.isCancel(value)) {
@@ -327,14 +307,7 @@ export async function createTransaction() {
         message: 'Transaction data (hex)',
         placeholder: '0x',
         initialValue: '0x',
-        validate: (val) => {
-          if (!val) return 'Data is required (use 0x for empty)'
-          if (!val.startsWith('0x')) return 'Data must start with 0x'
-          if (val.length > 2 && !/^0x[0-9a-fA-F]*$/.test(val)) {
-            return 'Data must be valid hex'
-          }
-          return undefined
-        },
+        validate: (val) => validator.validateHexData(val),
       })) as `0x${string}`
 
       if (p.isCancel(data)) {
@@ -374,14 +347,7 @@ export async function createTransaction() {
     const nonceInput = (await p.text({
       message: 'Transaction nonce (leave empty for default)',
       placeholder: `${currentNonce} (recommended: current nonce)`,
-      validate: (value) => {
-        if (!value) return undefined // Empty is OK (will use default)
-        const num = parseInt(value, 10)
-        if (isNaN(num) || num < 0) return 'Nonce must be a non-negative number'
-        if (num < currentNonce)
-          return `Nonce cannot be lower than current Safe nonce (${currentNonce})`
-        return undefined
-      },
+      validate: (value) => validator.validateNonce(value, currentNonce),
     })) as string
 
     if (p.isCancel(nonceInput)) {
diff --git a/src/commands/tx/execute.ts b/src/commands/tx/execute.ts
index 2831329..7e64565 100644
--- a/src/commands/tx/execute.ts
+++ b/src/commands/tx/execute.ts
@@ -173,7 +173,7 @@ export async function executeTransaction(safeTxHash?: string) {
     let privateKey: string
     try {
       privateKey = walletStorage.getPrivateKey(activeWallet.id, password)
-    } catch (error) {
+    } catch {
       spinner2.stop('Failed')
       p.log.error('Invalid password')
       p.outro('Failed')
diff --git a/src/commands/tx/import.ts b/src/commands/tx/import.ts
index 25cd372..a00faca 100644
--- a/src/commands/tx/import.ts
+++ b/src/commands/tx/import.ts
@@ -7,7 +7,7 @@ import { getSafeStorage } from '../../storage/safe-store.js'
 import { getTransactionStore } from '../../storage/transaction-store.js'
 import { getWalletStorage } from '../../storage/wallet-store.js'
 import { TransactionService } from '../../services/transaction-service.js'
-import { TxBuilderParser } from '../../services/tx-builder-parser.js'
+import { TxBuilderParser, type TxBuilderFormat } from '../../services/tx-builder-parser.js'
 import { SafeCLIError } from '../../utils/errors.js'
 import { validateAndChecksumAddress } from '../../utils/validation.js'
 import type { TransactionMetadata, TransactionSignature } from '../../types/transaction.js'
@@ -32,7 +32,7 @@ interface ImportData {
 /**
  * Import transactions from Transaction Builder format
  */
-async function importTransactionBuilderFormat(data: any) {
+async function importTransactionBuilderFormat(data: TxBuilderFormat) {
   const configStore = getConfigStore()
   const safeStorage = getSafeStorage()
   const transactionStore = getTransactionStore()
@@ -231,10 +231,10 @@ export async function importTransaction(input?: string) {
     }
 
     // Parse JSON
-    let parsedData: any
+    let parsedData: unknown
     try {
       parsedData = JSON.parse(jsonData)
-    } catch (error) {
+    } catch {
       throw new SafeCLIError('Invalid JSON format')
     }
 
diff --git a/src/commands/tx/pull.ts b/src/commands/tx/pull.ts
index 55cc855..ab9e290 100644
--- a/src/commands/tx/pull.ts
+++ b/src/commands/tx/pull.ts
@@ -10,6 +10,26 @@ import type { TransactionMetadata } from '../../types/transaction.js'
 import { renderScreen } from '../../ui/render.js'
 import { TransactionPullSuccessScreen, type TransactionPullResult } from '../../ui/screens/index.js'
 
+interface APITransaction {
+  safeTxHash: string
+  to: string
+  value: string
+  data: string
+  operation: 0 | 1
+  safeTxGas?: string
+  baseGas?: string
+  gasPrice?: string
+  gasToken?: string
+  refundReceiver?: string
+  nonce: number
+  proposer?: string
+  confirmations?: Array<{
+    owner: string
+    signature: string
+    submissionDate: string
+  }>
+}
+
 export async function pullTransactions(account?: string) {
   p.intro('Pull Transactions from Safe API')
 
@@ -116,7 +136,8 @@ export async function pullTransactions(account?: string) {
       let skipped = 0
       const results: TransactionPullResult[] = []
 
-      for (const remoteTx of remoteTxs) {
+      for (const remoteTxRaw of remoteTxs) {
+        const remoteTx = remoteTxRaw as unknown as APITransaction
         const safeTxHash = remoteTx.safeTxHash
         const localTx = transactionStore.getTransaction(safeTxHash)
 
@@ -151,7 +172,7 @@ export async function pullTransactions(account?: string) {
             transactionStore.addSignature(safeTxHash, {
               signer: confirmation.owner as Address,
               signature: confirmation.signature,
-              signedAt: new Date(confirmation.submissionDate),
+              signedAt: new Date(confirmation.submissionDate).toISOString(),
             })
           }
 
@@ -167,16 +188,20 @@ export async function pullTransactions(account?: string) {
             (localTx.signatures || []).map((sig) => sig.signer.toLowerCase())
           )
 
-          const newSignatures = (remoteTx.confirmations || []).filter(
-            (conf: any) => !localSigners.has(conf.owner.toLowerCase())
-          )
+          const newSignatures = (
+            remoteTx.confirmations as Array<{
+              owner: string
+              signature: string
+              submissionDate: string
+            }> || []
+          ).filter((conf) => !localSigners.has(conf.owner.toLowerCase()))
 
           if (newSignatures.length > 0) {
             for (const confirmation of newSignatures) {
               transactionStore.addSignature(safeTxHash, {
                 signer: confirmation.owner as Address,
                 signature: confirmation.signature,
-                signedAt: new Date(confirmation.submissionDate),
+                signedAt: new Date(confirmation.submissionDate).toISOString(),
               })
             }
 
diff --git a/src/commands/tx/push.ts b/src/commands/tx/push.ts
index 5ba13a6..177bf90 100644
--- a/src/commands/tx/push.ts
+++ b/src/commands/tx/push.ts
@@ -121,8 +121,8 @@ export async function pushTransaction(safeTxHash?: string) {
         spinner.stop('Transaction already exists on service')
 
         // Add new signatures
-        const remoteSignatures = existingTx.confirmations || []
-        const remoteSigners = new Set(remoteSignatures.map((conf: any) => conf.owner.toLowerCase()))
+        const remoteSignatures = existingTx.confirmations as Array<{ owner: string }> || []
+        const remoteSigners = new Set(remoteSignatures.map((conf) => conf.owner.toLowerCase()))
 
         const newSignatures = (transaction.signatures || []).filter(
           (sig) => !remoteSigners.has(sig.signer.toLowerCase())
diff --git a/src/commands/tx/sign.ts b/src/commands/tx/sign.ts
index 66109aa..a030e4f 100644
--- a/src/commands/tx/sign.ts
+++ b/src/commands/tx/sign.ts
@@ -166,7 +166,7 @@ export async function signTransaction(safeTxHash?: string) {
     let privateKey: string
     try {
       privateKey = walletStorage.getPrivateKey(activeWallet.id, password)
-    } catch (error) {
+    } catch {
       spinner2.stop('Failed')
       p.log.error('Invalid password')
       p.outro('Failed')
@@ -182,7 +182,7 @@ export async function signTransaction(safeTxHash?: string) {
     transactionStore.addSignature(selectedSafeTxHash, {
       signer: activeWallet.address as Address,
       signature,
-      signedAt: new Date(),
+      signedAt: new Date().toISOString(),
     })
 
     // Update status to signed if not already
diff --git a/src/commands/tx/sync.ts b/src/commands/tx/sync.ts
index be2eefc..9aa687f 100644
--- a/src/commands/tx/sync.ts
+++ b/src/commands/tx/sync.ts
@@ -11,6 +11,26 @@ import type { TransactionMetadata } from '../../types/transaction.js'
 import { renderScreen } from '../../ui/render.js'
 import { TransactionSyncSuccessScreen } from '../../ui/screens/index.js'
 
+interface APITransaction {
+  safeTxHash: string
+  to: string
+  value: string
+  data: string
+  operation: 0 | 1
+  safeTxGas?: string
+  baseGas?: string
+  gasPrice?: string
+  gasToken?: string
+  refundReceiver?: string
+  nonce: number
+  proposer?: string
+  confirmations?: Array<{
+    owner: string
+    signature: string
+    submissionDate: string
+  }>
+}
+
 export async function syncTransactions(account?: string) {
   p.intro('Sync Transactions with Safe API')
 
@@ -116,7 +136,8 @@ export async function syncTransactions(account?: string) {
       const remoteTxs = await apiService.getPendingTransactions(address)
       spinner.stop(`Found ${remoteTxs.length} pending transaction(s)`)
 
-      for (const remoteTx of remoteTxs) {
+      for (const remoteTxRaw of remoteTxs) {
+        const remoteTx = remoteTxRaw as unknown as APITransaction
         const safeTxHash = remoteTx.safeTxHash
         const localTx = transactionStore.getTransaction(safeTxHash)
 
@@ -148,7 +169,7 @@ export async function syncTransactions(account?: string) {
             transactionStore.addSignature(safeTxHash, {
               signer: confirmation.owner as Address,
               signature: confirmation.signature,
-              signedAt: new Date(confirmation.submissionDate),
+              signedAt: new Date(confirmation.submissionDate).toISOString(),
             })
           }
 
@@ -157,16 +178,20 @@ export async function syncTransactions(account?: string) {
           const localSigners = new Set(
             (localTx.signatures || []).map((sig) => sig.signer.toLowerCase())
           )
-          const newSignatures = (remoteTx.confirmations || []).filter(
-            (conf: any) => !localSigners.has(conf.owner.toLowerCase())
-          )
+          const newSignatures = (
+            remoteTx.confirmations as Array<{
+              owner: string
+              signature: string
+              submissionDate: string
+            }> || []
+          ).filter((conf) => !localSigners.has(conf.owner.toLowerCase()))
 
           if (newSignatures.length > 0) {
             for (const confirmation of newSignatures) {
               transactionStore.addSignature(safeTxHash, {
                 signer: confirmation.owner as Address,
                 signature: confirmation.signature,
-                signedAt: new Date(confirmation.submissionDate),
+                signedAt: new Date(confirmation.submissionDate).toISOString(),
               })
             }
 
@@ -212,10 +237,8 @@ export async function syncTransactions(account?: string) {
 
         if (existingTx) {
           // Push new signatures
-          const remoteSignatures = existingTx.confirmations || []
-          const remoteSigners = new Set(
-            remoteSignatures.map((conf: any) => conf.owner.toLowerCase())
-          )
+          const remoteSignatures = existingTx.confirmations as Array<{ owner: string }> || []
+          const remoteSigners = new Set(remoteSignatures.map((conf) => conf.owner.toLowerCase()))
 
           const newSignatures = (localTx.signatures || []).filter(
             (sig) => !remoteSigners.has(sig.signer.toLowerCase())
diff --git a/src/commands/wallet/import.ts b/src/commands/wallet/import.ts
index 7dcf7b7..040c953 100644
--- a/src/commands/wallet/import.ts
+++ b/src/commands/wallet/import.ts
@@ -1,7 +1,7 @@
 import * as p from '@clack/prompts'
 import { type Address } from 'viem'
 import { getWalletStorage } from '../../storage/wallet-store.js'
-import { isValidPrivateKey } from '../../utils/validation.js'
+import { getValidationService } from '../../services/validation-service.js'
 import { logError } from '../../ui/messages.js'
 import { renderScreen } from '../../ui/render.js'
 import { WalletImportSuccessScreen } from '../../ui/screens/index.js'
@@ -10,15 +10,12 @@ export async function importWallet() {
   p.intro('Import Wallet')
 
   const walletStorage = getWalletStorage()
+  const validator = getValidationService()
 
   // Get password for encryption
   const password = await p.password({
     message: 'Create a password to encrypt your wallet:',
-    validate: (value) => {
-      if (!value) return 'Password is required'
-      if (value.length < 8) return 'Password must be at least 8 characters'
-      return undefined
-    },
+    validate: (value) => validator.validatePassword(value, 8),
   })
 
   if (p.isCancel(password)) {
@@ -28,10 +25,7 @@ export async function importWallet() {
 
   const confirmPassword = await p.password({
     message: 'Confirm password:',
-    validate: (value) => {
-      if (value !== password) return 'Passwords do not match'
-      return undefined
-    },
+    validate: (value) => validator.validatePasswordConfirmation(value, password as string),
   })
 
   if (p.isCancel(confirmPassword)) {
@@ -44,13 +38,7 @@ export async function importWallet() {
   // Get private key
   const privateKey = await p.password({
     message: 'Enter your private key:',
-    validate: (value) => {
-      if (!value) return 'Private key is required'
-      if (!isValidPrivateKey(value)) {
-        return 'Invalid private key format. Must be a 64-character hex string (with or without 0x prefix)'
-      }
-      return undefined
-    },
+    validate: (value) => validator.validatePrivateKey(value),
   })
 
   if (p.isCancel(privateKey)) {
@@ -62,7 +50,7 @@ export async function importWallet() {
   const name = await p.text({
     message: 'Give this wallet a name:',
     placeholder: 'my-wallet',
-    validate: (value) => (!value ? 'Wallet name is required' : undefined),
+    validate: (value) => validator.validateRequired(value, 'Wallet name'),
   })
 
   if (p.isCancel(name)) {
diff --git a/src/services/abi-service.ts b/src/services/abi-service.ts
index 9c4ebe2..e7d780b 100644
--- a/src/services/abi-service.ts
+++ b/src/services/abi-service.ts
@@ -2,6 +2,33 @@ import type { Address } from 'viem'
 import type { ChainConfig } from '../types/config.js'
 import { SafeCLIError } from '../utils/errors.js'
 
+/**
+ * Fetch with timeout support
+ */
+async function fetchWithTimeout(
+  url: string,
+  options: RequestInit = {},
+  timeoutMs = 10000
+): Promise<Response> {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
+
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal,
+    })
+    return response
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      throw new SafeCLIError(`Request timeout after ${timeoutMs}ms`)
+    }
+    throw error
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
 export interface ABIFunction {
   type: 'function'
   name: string
@@ -16,9 +43,23 @@ export interface ABIFunction {
     internalType?: string
   }>
   stateMutability: 'pure' | 'view' | 'nonpayable' | 'payable'
+  constant?: boolean
+  pure?: boolean
+  view?: boolean
+}
+
+export interface ABIItem {
+  type: string
+  name?: string
+  inputs?: Array<{
+    name: string
+    type: string
+    internalType?: string
+  }>
+  [key: string]: unknown
 }
 
-export type ABI = Array<ABIFunction | any>
+export type ABI = Array<ABIFunction | ABIItem>
 
 export interface ContractInfo {
   abi: ABI
@@ -63,7 +104,7 @@ export class ABIService {
       try {
         const info = await this.fetchFromEtherscan(address)
         if (info) return info
-      } catch (error) {
+      } catch {
         // Silently continue to Sourcify
       }
 
@@ -71,7 +112,7 @@ export class ABIService {
       try {
         const info = await this.fetchFromSourcify(address)
         if (info) return info
-      } catch (error) {
+      } catch {
         // Both failed
       }
     } else {
@@ -79,7 +120,7 @@ export class ABIService {
       try {
         const info = await this.fetchFromSourcify(address)
         if (info) return info
-      } catch (error) {
+      } catch {
         // Silently continue to Etherscan
       }
 
@@ -87,7 +128,7 @@ export class ABIService {
       try {
         const info = await this.fetchFromEtherscan(address)
         if (info) return info
-      } catch (error) {
+      } catch {
         // Both failed
       }
     }
@@ -132,11 +173,19 @@ export class ABIService {
       requestUrl += `&apikey=${this.etherscanApiKey}`
     }
 
-    const response = await fetch(requestUrl)
-    const data = (await response.json()) as any
+    const response = await fetchWithTimeout(requestUrl)
+    const data = (await response.json()) as {
+      status: string
+      result?: Array<{
+        ABI?: string
+        ContractName?: string
+        Proxy?: string
+        Implementation?: string
+      }>
+    }
 
     if (data.status === '1' && data.result && data.result[0]) {
-      const contractData = data.result[0] as any
+      const contractData = data.result[0]
 
       if (contractData.ABI && contractData.ABI !== 'Contract source code not verified') {
         // Check if this is a proxy contract (Etherscan V2 returns Proxy="1" and Implementation address)
@@ -165,19 +214,20 @@ export class ABIService {
     // Try full match first
     try {
       const url = `https://repo.sourcify.dev/contracts/full_match/${chainId}/${address}/metadata.json`
-      const response = await fetch(url)
+      const response = await fetchWithTimeout(url)
 
       if (response.ok) {
-        const metadata = (await response.json()) as any
+        const metadata = (await response.json()) as {
+          output?: { abi?: ABI }
+          settings?: { compilationTarget?: Record<string, string> }
+        }
         if (metadata.output?.abi) {
           // Extract contract name from settings.compilationTarget
           let contractName: string | undefined
           if (metadata.settings?.compilationTarget) {
-            const targets = Object.values(
-              metadata.settings.compilationTarget as Record<string, any>
-            )
+            const targets = Object.values(metadata.settings.compilationTarget)
             if (targets.length > 0) {
-              contractName = targets[0] as string
+              contractName = targets[0]
             }
           }
 
@@ -187,26 +237,27 @@ export class ABIService {
           }
         }
       }
-    } catch (error) {
+    } catch {
       // Try partial match
     }
 
     // Try partial match
     try {
       const url = `https://repo.sourcify.dev/contracts/partial_match/${chainId}/${address}/metadata.json`
-      const response = await fetch(url)
+      const response = await fetchWithTimeout(url)
 
       if (response.ok) {
-        const metadata = (await response.json()) as any
+        const metadata = (await response.json()) as {
+          output?: { abi?: ABI }
+          settings?: { compilationTarget?: Record<string, string> }
+        }
         if (metadata.output?.abi) {
           // Extract contract name from settings.compilationTarget
           let contractName: string | undefined
           if (metadata.settings?.compilationTarget) {
-            const targets = Object.values(
-              metadata.settings.compilationTarget as Record<string, any>
-            )
+            const targets = Object.values(metadata.settings.compilationTarget)
             if (targets.length > 0) {
-              contractName = targets[0] as string
+              contractName = targets[0]
             }
           }
 
@@ -216,7 +267,7 @@ export class ABIService {
           }
         }
       }
-    } catch (error) {
+    } catch {
       // Failed
     }
 
diff --git a/src/services/api-service.ts b/src/services/api-service.ts
index d83d2b5..a670635 100644
--- a/src/services/api-service.ts
+++ b/src/services/api-service.ts
@@ -86,7 +86,7 @@ export class SafeTransactionServiceAPI {
   /**
    * Get pending transactions for a Safe
    */
-  async getPendingTransactions(safeAddress: Address): Promise<any[]> {
+  async getPendingTransactions(safeAddress: Address): Promise<Array<Record<string, unknown>>> {
     try {
       const result = await this.apiKit.getPendingTransactions(safeAddress)
       return result.results || []
@@ -100,7 +100,7 @@ export class SafeTransactionServiceAPI {
   /**
    * Get all transactions for a Safe
    */
-  async getAllTransactions(safeAddress: Address): Promise<any[]> {
+  async getAllTransactions(safeAddress: Address): Promise<Array<Record<string, unknown>>> {
     try {
       const result = await this.apiKit.getAllTransactions(safeAddress)
       return result.results || []
@@ -114,7 +114,7 @@ export class SafeTransactionServiceAPI {
   /**
    * Get a specific transaction by safeTxHash
    */
-  async getTransaction(safeTxHash: string): Promise<any> {
+  async getTransaction(safeTxHash: string): Promise<Record<string, unknown> | null> {
     try {
       return await this.apiKit.getTransaction(safeTxHash)
     } catch (error) {
diff --git a/src/services/contract-service.ts b/src/services/contract-service.ts
index eb3ef7f..1ebb11c 100644
--- a/src/services/contract-service.ts
+++ b/src/services/contract-service.ts
@@ -25,7 +25,7 @@ export class ContractService {
     try {
       const client = createPublicClient({
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
@@ -59,7 +59,7 @@ export class ContractService {
     try {
       const client = createPublicClient({
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
@@ -129,7 +129,7 @@ export class ContractService {
       }
 
       return null
-    } catch (error) {
+    } catch {
       // Not a proxy or error reading storage
       return null
     }
diff --git a/src/services/safe-service.ts b/src/services/safe-service.ts
index c7ff0a7..ba50e35 100644
--- a/src/services/safe-service.ts
+++ b/src/services/safe-service.ts
@@ -10,7 +10,7 @@ import { SafeCLIError } from '../utils/errors.js'
 import { normalizePrivateKey } from '../utils/validation.js'
 
 // ESM/CommonJS interop: Access the Safe class from the default export
-const Safe = (SafeSDK as any).default
+const Safe = (SafeSDK as unknown as { default: typeof SafeSDK }).default
 
 export interface SafeCreationConfig {
   owners: Address[]
@@ -112,7 +112,7 @@ export class SafeService {
       const client = createWalletClient({
         account,
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
@@ -136,7 +136,7 @@ export class SafeService {
       // Wait for confirmation
       const publicClient = createPublicClient({
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
@@ -168,7 +168,7 @@ export class SafeService {
       // Check if Safe is deployed
       const publicClient = createPublicClient({
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
diff --git a/src/services/transaction-builder.ts b/src/services/transaction-builder.ts
index 03888e2..b79a757 100644
--- a/src/services/transaction-builder.ts
+++ b/src/services/transaction-builder.ts
@@ -22,7 +22,7 @@ export class TransactionBuilder {
    * Build transaction data for a function call
    */
   async buildFunctionCall(func: ABIFunction): Promise<TransactionBuilderResult> {
-    const args: any[] = []
+    const args: unknown[] = []
 
     // Get value if function is payable
     let value = '0'
@@ -81,7 +81,7 @@ export class TransactionBuilder {
   /**
    * Prompt for a single parameter value
    */
-  private async promptForParameter(name: string, type: string): Promise<any> {
+  private async promptForParameter(name: string, type: string): Promise<unknown> {
     const value = await p.text({
       message: `${name} (${type}):`,
       placeholder: this.getPlaceholder(type),
@@ -126,7 +126,7 @@ export class TransactionBuilder {
   /**
    * Parse parameter value based on type
    */
-  private parseParameter(value: string, type: string): any {
+  private parseParameter(value: string, type: string): unknown {
     // Address
     if (type === 'address') {
       if (!/^0x[a-fA-F0-9]{40}$/.test(value)) {
diff --git a/src/services/transaction-service.ts b/src/services/transaction-service.ts
index c654bc8..dd50612 100644
--- a/src/services/transaction-service.ts
+++ b/src/services/transaction-service.ts
@@ -7,7 +7,7 @@ import { SafeCLIError } from '../utils/errors.js'
 import { normalizePrivateKey } from '../utils/validation.js'
 
 // ESM/CommonJS interop: Access the Safe class from the default export
-const Safe = (SafeSDK as any).default
+const Safe = (SafeSDK as unknown as { default: typeof SafeSDK }).default
 
 export interface SafeTransactionData {
   to: Address
@@ -172,7 +172,7 @@ export class TransactionService {
         safeTransaction.addSignature({
           signer: sig.signer,
           data: sig.signature,
-        } as any)
+        } as unknown as Parameters<typeof safeTransaction.addSignature>[0])
       }
 
       // Execute the transaction
@@ -180,7 +180,7 @@ export class TransactionService {
 
       const client = createPublicClient({
         chain: {
-          id: parseInt(this.chain.chainId),
+          id: parseInt(this.chain.chainId, 10),
           name: this.chain.name,
           nativeCurrency: {
             name: this.chain.currency,
diff --git a/src/services/tx-builder-parser.ts b/src/services/tx-builder-parser.ts
index 8b8819c..4a0d255 100644
--- a/src/services/tx-builder-parser.ts
+++ b/src/services/tx-builder-parser.ts
@@ -18,7 +18,7 @@ export interface TxBuilderTransaction {
     name: string
     payable: boolean
   }
-  contractInputsValues?: Record<string, any>
+  contractInputsValues?: Record<string, unknown>
 }
 
 export interface TxBuilderFormat {
@@ -53,24 +53,25 @@ export class TxBuilderParser {
   /**
    * Check if JSON matches Transaction Builder format
    */
-  static isTxBuilderFormat(data: any): data is TxBuilderFormat {
+  static isTxBuilderFormat(data: unknown): data is TxBuilderFormat {
     return (
-      data &&
+      !!data &&
       typeof data === 'object' &&
       'version' in data &&
       'chainId' in data &&
       'meta' in data &&
       'transactions' in data &&
-      Array.isArray(data.transactions) &&
-      typeof data.meta === 'object' &&
-      'createdFromSafeAddress' in data.meta
+      Array.isArray((data as { transactions: unknown }).transactions) &&
+      typeof (data as { meta: unknown }).meta === 'object' &&
+      (data as { meta: unknown }).meta !== null &&
+      'createdFromSafeAddress' in ((data as { meta: object }).meta)
     )
   }
 
   /**
    * Validate Transaction Builder JSON structure
    */
-  static validate(data: any): asserts data is TxBuilderFormat {
+  static validate(data: unknown): asserts data is TxBuilderFormat {
     if (!this.isTxBuilderFormat(data)) {
       throw new SafeCLIError('Invalid Transaction Builder format: missing required fields')
     }
@@ -133,7 +134,7 @@ export class TxBuilderParser {
    */
   private static encodeContractMethod(
     method: NonNullable<TxBuilderTransaction['contractMethod']>,
-    inputValues: Record<string, any>
+    inputValues: Record<string, unknown>
   ): Hex {
     try {
       // Build ABI for this function
@@ -176,7 +177,7 @@ export class TxBuilderParser {
   /**
    * Parse a value based on its Solidity type
    */
-  private static parseValue(value: any, type: string): any {
+  private static parseValue(value: unknown, type: string): unknown {
     // If value is already the correct type, return it
     if (value === null || value === undefined) {
       throw new Error('Value cannot be null or undefined')
diff --git a/src/services/validation-service.ts b/src/services/validation-service.ts
new file mode 100644
index 0000000..3774bed
--- /dev/null
+++ b/src/services/validation-service.ts
@@ -0,0 +1,385 @@
+import { isAddress, isHex, getAddress, type Address } from 'viem'
+import { ValidationError } from '../utils/errors.js'
+
+/**
+ * Centralized validation service for all input validation across the CLI.
+ *
+ * This service provides two types of validation methods:
+ * 1. `validate*()` - Returns error message string or undefined (for @clack/prompts)
+ * 2. `assert*()` - Throws ValidationError (for business logic)
+ */
+export class ValidationService {
+  /**
+   * Validates an Ethereum address
+   * @returns Error message or undefined if valid
+   */
+  validateAddress(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Address is required'
+    }
+    if (!isAddress(value)) {
+      return 'Invalid Ethereum address'
+    }
+    return undefined
+  }
+
+  /**
+   * Asserts an Ethereum address is valid and returns checksummed version
+   * @throws ValidationError if invalid
+   */
+  assertAddress(value: string, fieldName = 'Address'): Address {
+    const error = this.validateAddress(value)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+    try {
+      return getAddress(value)
+    } catch (error) {
+      throw new ValidationError(
+        `${fieldName}: Invalid address checksum - ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Validates a private key (64 hex characters with optional 0x prefix)
+   * @returns Error message or undefined if valid
+   */
+  validatePrivateKey(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Private key is required'
+    }
+    const key = value.startsWith('0x') ? value.slice(2) : value
+    if (!isHex(`0x${key}`) || key.length !== 64) {
+      return 'Invalid private key format. Must be a 64-character hex string (with or without 0x prefix)'
+    }
+    return undefined
+  }
+
+  /**
+   * Asserts a private key is valid and returns normalized version
+   * @throws ValidationError if invalid
+   */
+  assertPrivateKey(value: string, fieldName = 'Private key'): `0x${string}` {
+    const error = this.validatePrivateKey(value)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+    return value.startsWith('0x') ? (value as `0x${string}`) : (`0x${value}` as `0x${string}`)
+  }
+
+  /**
+   * Validates a chain ID (positive integer)
+   * @returns Error message or undefined if valid
+   */
+  validateChainId(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Chain ID is required'
+    }
+    const parsed = parseInt(value, 10)
+    if (isNaN(parsed) || parsed <= 0) {
+      return 'Chain ID must be a positive integer'
+    }
+    return undefined
+  }
+
+  /**
+   * Asserts a chain ID is valid
+   * @throws ValidationError if invalid
+   */
+  assertChainId(value: string, fieldName = 'Chain ID'): void {
+    const error = this.validateChainId(value)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+  }
+
+  /**
+   * Validates a URL
+   * @returns Error message or undefined if valid
+   */
+  validateUrl(value: unknown, required = true): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return required ? 'URL is required' : undefined
+    }
+    try {
+      new URL(value)
+      return undefined
+    } catch {
+      return 'Invalid URL format'
+    }
+  }
+
+  /**
+   * Asserts a URL is valid
+   * @throws ValidationError if invalid
+   */
+  assertUrl(value: string, fieldName = 'URL'): void {
+    const error = this.validateUrl(value)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+  }
+
+  /**
+   * Validates a password (minimum length)
+   * @returns Error message or undefined if valid
+   */
+  validatePassword(value: unknown, minLength = 8): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Password is required'
+    }
+    if (value.length < minLength) {
+      return `Password must be at least ${minLength} characters`
+    }
+    return undefined
+  }
+
+  /**
+   * Validates password confirmation matches
+   * @returns Error message or undefined if valid
+   */
+  validatePasswordConfirmation(value: unknown, original: string): string | undefined {
+    if (value !== original) {
+      return 'Passwords do not match'
+    }
+    return undefined
+  }
+
+  /**
+   * Validates a threshold value
+   * @returns Error message or undefined if valid
+   */
+  validateThreshold(value: unknown, min = 1, max?: number): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Threshold is required'
+    }
+    const threshold = parseInt(value, 10)
+    if (isNaN(threshold)) {
+      return 'Threshold must be a number'
+    }
+    if (threshold < min) {
+      return `Threshold must be at least ${min}`
+    }
+    if (max !== undefined && threshold > max) {
+      return `Threshold cannot exceed ${max} (number of owners)`
+    }
+    return undefined
+  }
+
+  /**
+   * Asserts a threshold is valid
+   * @throws ValidationError if invalid
+   */
+  assertThreshold(value: number, min: number, max: number, fieldName = 'Threshold'): void {
+    if (value < min) {
+      throw new ValidationError(`${fieldName} must be at least ${min}`)
+    }
+    if (value > max) {
+      throw new ValidationError(`${fieldName} cannot exceed ${max}`)
+    }
+  }
+
+  /**
+   * Validates a nonce value
+   * @returns Error message or undefined if valid
+   */
+  validateNonce(value: unknown, currentNonce?: number): string | undefined {
+    if (!value) {
+      return undefined // Empty is OK (will use default)
+    }
+    if (typeof value !== 'string') {
+      return 'Invalid nonce'
+    }
+    const nonce = parseInt(value, 10)
+    if (isNaN(nonce) || nonce < 0) {
+      return 'Nonce must be a non-negative number'
+    }
+    if (currentNonce !== undefined && nonce < currentNonce) {
+      return `Nonce cannot be lower than current Safe nonce (${currentNonce})`
+    }
+    return undefined
+  }
+
+  /**
+   * Validates a Wei value (string representing BigInt)
+   * @returns Error message or undefined if valid
+   */
+  validateWeiValue(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Value is required'
+    }
+    try {
+      BigInt(value)
+      return undefined
+    } catch {
+      return 'Invalid number'
+    }
+  }
+
+  /**
+   * Validates hex data
+   * @returns Error message or undefined if valid
+   */
+  validateHexData(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Data is required (use 0x for empty)'
+    }
+    if (!value.startsWith('0x')) {
+      return 'Data must start with 0x'
+    }
+    if (value.length > 2 && !/^0x[0-9a-fA-F]*$/.test(value)) {
+      return 'Data must be valid hex'
+    }
+    return undefined
+  }
+
+  /**
+   * Validates a required text field
+   * @returns Error message or undefined if valid
+   */
+  validateRequired(value: unknown, fieldName = 'Value'): string | undefined {
+    if (!value || (typeof value === 'string' && value.trim().length === 0)) {
+      return `${fieldName} is required`
+    }
+    return undefined
+  }
+
+  /**
+   * Validates an EIP-3770 short name (lowercase alphanumeric with hyphens)
+   * @returns Error message or undefined if valid
+   */
+  validateShortName(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'Short name is required'
+    }
+    if (!/^[a-z0-9-]+$/.test(value)) {
+      return 'Short name must be lowercase alphanumeric with hyphens'
+    }
+    return undefined
+  }
+
+  /**
+   * Validates that an address is one of the provided owners
+   * @returns Error message or undefined if valid
+   */
+  validateOwnerAddress(value: unknown, owners: Address[]): string | undefined {
+    const addressError = this.validateAddress(value)
+    if (addressError) return addressError
+
+    const normalized = (value as string).toLowerCase()
+    if (!owners.some((owner) => owner.toLowerCase() === normalized)) {
+      return 'Address is not an owner of this Safe'
+    }
+    return undefined
+  }
+
+  /**
+   * Validates that an address is NOT one of the provided owners
+   * @returns Error message or undefined if valid
+   */
+  validateNonOwnerAddress(value: unknown, owners: Address[]): string | undefined {
+    const addressError = this.validateAddress(value)
+    if (addressError) return addressError
+
+    const normalized = (value as string).toLowerCase()
+    if (owners.some((owner) => owner.toLowerCase() === normalized)) {
+      return 'Address is already an owner of this Safe'
+    }
+    return undefined
+  }
+
+  /**
+   * Validates JSON string
+   * @returns Error message or undefined if valid
+   */
+  validateJson(value: unknown): string | undefined {
+    if (!value || typeof value !== 'string') {
+      return 'JSON is required'
+    }
+    try {
+      JSON.parse(value)
+      return undefined
+    } catch {
+      return 'Invalid JSON format'
+    }
+  }
+
+  /**
+   * Asserts JSON is valid and returns parsed object
+   * @throws ValidationError if invalid
+   */
+  assertJson<T = unknown>(value: string, fieldName = 'JSON'): T {
+    const error = this.validateJson(value)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+    try {
+      return JSON.parse(value) as T
+    } catch (error) {
+      throw new ValidationError(
+        `${fieldName}: Parse error - ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  /**
+   * Validates a positive integer
+   * @returns Error message or undefined if valid
+   */
+  validatePositiveInteger(value: unknown, fieldName = 'Value'): string | undefined {
+    if (!value) {
+      return `${fieldName} is required`
+    }
+    const num = typeof value === 'string' ? parseInt(value, 10) : value
+    if (typeof num !== 'number' || isNaN(num) || num <= 0 || !Number.isInteger(num)) {
+      return `${fieldName} must be a positive integer`
+    }
+    return undefined
+  }
+
+  /**
+   * Validates an array of addresses
+   * @returns Error message or undefined if valid
+   */
+  validateAddresses(addresses: unknown[]): string | undefined {
+    if (!Array.isArray(addresses) || addresses.length === 0) {
+      return 'At least one address is required'
+    }
+    for (let i = 0; i < addresses.length; i++) {
+      const error = this.validateAddress(addresses[i])
+      if (error) {
+        return `Address ${i + 1}: ${error}`
+      }
+    }
+    // Check for duplicates
+    const normalized = addresses.map((addr) => (addr as string).toLowerCase())
+    const unique = new Set(normalized)
+    if (unique.size !== normalized.length) {
+      return 'Duplicate addresses are not allowed'
+    }
+    return undefined
+  }
+
+  /**
+   * Asserts an array of addresses is valid and returns checksummed versions
+   * @throws ValidationError if invalid
+   */
+  assertAddresses(addresses: string[], fieldName = 'Addresses'): Address[] {
+    const error = this.validateAddresses(addresses)
+    if (error) {
+      throw new ValidationError(`${fieldName}: ${error}`)
+    }
+    return addresses.map((addr) => this.assertAddress(addr, fieldName))
+  }
+}
+
+// Singleton instance
+let validationService: ValidationService | null = null
+
+export function getValidationService(): ValidationService {
+  if (!validationService) {
+    validationService = new ValidationService()
+  }
+  return validationService
+}
diff --git a/src/storage/transaction-store.ts b/src/storage/transaction-store.ts
index 3014206..596aeea 100644
--- a/src/storage/transaction-store.ts
+++ b/src/storage/transaction-store.ts
@@ -17,7 +17,7 @@ export class TransactionStore {
 
   constructor() {
     this.store = new Conf<TransactionStoreSchema>({
-      projectName: 'safe-cli-nodejs',
+      projectName: 'safe-cli',
       configName: 'transactions',
       defaults: {
         transactions: {},
@@ -40,7 +40,7 @@ export class TransactionStore {
       metadata,
       signatures: [],
       createdBy,
-      createdAt: new Date(),
+      createdAt: new Date().toISOString(),
     }
 
     const transactions = this.store.get('transactions')
@@ -120,7 +120,7 @@ export class TransactionStore {
 
     transaction.status = status
     if (status === 'executed') {
-      transaction.executedAt = new Date()
+      transaction.executedAt = new Date().toISOString()
       if (txHash) {
         transaction.txHash = txHash
       }
diff --git a/src/storage/wallet-store.ts b/src/storage/wallet-store.ts
index c4c0f6b..97f46a7 100644
--- a/src/storage/wallet-store.ts
+++ b/src/storage/wallet-store.ts
@@ -26,7 +26,7 @@ class SecureStorage {
 
     const cipher = createCipheriv(this.algorithm, key, iv)
     const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()])
-    const tag = (cipher as any).getAuthTag()
+    const tag = (cipher as unknown as { getAuthTag: () => Buffer }).getAuthTag()
 
     // Combine salt + iv + tag + encrypted
     const result = Buffer.concat([salt, iv, tag, encrypted])
@@ -46,7 +46,7 @@ class SecureStorage {
 
     const key = this.deriveKey(password, salt)
     const decipher = createDecipheriv(this.algorithm, key, iv)
-    ;(decipher as any).setAuthTag(tag)
+    ;(decipher as unknown as { setAuthTag: (tag: Buffer) => void }).setAuthTag(tag)
 
     const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()])
     return decrypted.toString('utf8')
@@ -146,7 +146,7 @@ export class WalletStorageService {
 
     try {
       return this.secureStorage.decrypt(encrypted, pwd)
-    } catch (error) {
+    } catch {
       throw new WalletError('Failed to decrypt private key. Incorrect password?')
     }
   }
diff --git a/src/test/helpers/mocks.ts b/src/test/helpers/mocks.ts
index 2976608..fb29459 100644
--- a/src/test/helpers/mocks.ts
+++ b/src/test/helpers/mocks.ts
@@ -4,7 +4,7 @@ import { vi } from 'vitest'
  * Mock implementations for storage layers
  */
 
-export function createMockConfigStore(): any {
+export function createMockConfigStore(): Record<string, unknown> {
   return {
     getConfig: vi.fn().mockReturnValue({
       chains: {
@@ -44,7 +44,7 @@ export function createMockConfigStore(): any {
       },
     }),
     getChain: vi.fn().mockImplementation((chainId: string) => {
-      const chains: any = {
+      const chains: Record<string, unknown> = {
         '1': {
           chainId: '1',
           name: 'Ethereum',
@@ -71,7 +71,7 @@ export function createMockConfigStore(): any {
   }
 }
 
-export function createMockWalletStorage(): any {
+export function createMockWalletStorage(): Record<string, unknown> {
   return {
     importWallet: vi.fn(),
     getAllWallets: vi.fn().mockReturnValue([]),
@@ -84,7 +84,7 @@ export function createMockWalletStorage(): any {
   }
 }
 
-export function createMockSafeStorage(): any {
+export function createMockSafeStorage(): Record<string, unknown> {
   return {
     createSafe: vi.fn(),
     getAllSafes: vi.fn().mockReturnValue([]),
@@ -97,7 +97,7 @@ export function createMockSafeStorage(): any {
   }
 }
 
-export function createMockTransactionStore(): any {
+export function createMockTransactionStore(): Record<string, unknown> {
   return {
     createTransaction: vi.fn(),
     getTransaction: vi.fn(),
@@ -145,7 +145,7 @@ export function mockConsole() {
   const logs: string[] = []
   const originalLog = console.log
 
-  console.log = vi.fn((...args: any[]) => {
+  console.log = vi.fn((...args: unknown[]) => {
     logs.push(args.map((a) => String(a)).join(' '))
   })
 
diff --git a/src/tests/integration/transaction.test.ts b/src/tests/integration/transaction.test.ts
index 85ccc44..9404d8c 100644
--- a/src/tests/integration/transaction.test.ts
+++ b/src/tests/integration/transaction.test.ts
@@ -268,7 +268,7 @@ describe('Transaction Integration Tests', () => {
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: TEST_ADDRESS,
         signature: '0x' + '1'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       const tx = transactionStore.getTransaction(TEST_SAFE_TX_HASH)
@@ -280,13 +280,13 @@ describe('Transaction Integration Tests', () => {
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: TEST_ADDRESS,
         signature: '0x' + '1'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8' as Address,
         signature: '0x' + '2'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       const tx = transactionStore.getTransaction(TEST_SAFE_TX_HASH)
@@ -297,13 +297,13 @@ describe('Transaction Integration Tests', () => {
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: TEST_ADDRESS,
         signature: '0x' + '1'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: TEST_ADDRESS,
         signature: '0x' + '2'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       const tx = transactionStore.getTransaction(TEST_SAFE_TX_HASH)
@@ -425,7 +425,7 @@ describe('Transaction Integration Tests', () => {
       transactionStore.addSignature(TEST_SAFE_TX_HASH, {
         signer: TEST_ADDRESS,
         signature: '0x' + '1'.repeat(130),
-        signedAt: new Date(),
+        signedAt: new Date().toISOString(),
       })
 
       // Create new instance
diff --git a/src/types/transaction.ts b/src/types/transaction.ts
index 486d4b2..47ab033 100644
--- a/src/types/transaction.ts
+++ b/src/types/transaction.ts
@@ -23,7 +23,7 @@ export interface TransactionMetadata {
 export interface TransactionSignature {
   signer: Address
   signature: string
-  signedAt: Date
+  signedAt: string // ISO 8601 format
 }
 
 export interface StoredTransaction {
@@ -34,8 +34,8 @@ export interface StoredTransaction {
   metadata: TransactionMetadata
   signatures: TransactionSignature[]
   createdBy: Address
-  createdAt: Date
-  executedAt?: Date
+  createdAt: string // ISO 8601 format
+  executedAt?: string // ISO 8601 format
   txHash?: string // On-chain transaction hash after execution
 }