latest versions

2026-02-12 12:26:39 -08:00
parent 82b5ed0b3c
commit 78cadee871
97 changed files with 3288 additions and 124 deletions
--- a/btcphrasechecker/README.md
+++ b/btcphrasechecker/README.md
@@ -0,0 +1,271 @@
+# Bitcoin Phrase Checker
+
+A modular and extensible Go program that derives Bitcoin addresses from a BIP39 mnemonic phrase and provides comprehensive transaction history and balance analysis using public APIs.
+
+## Features
+
+### Core Functionality
+- **BIP39 Support**: Validates and processes mnemonic phrases (12/24 words) with optional passphrases
+- **Multi-Path Derivation**: Automatically derives addresses from standard Bitcoin derivation paths:
+  - **BIP44 (Legacy)**: `m/44'/0'/0'/0` - P2PKH addresses (starting with `1...`)
+  - **BIP49 (SegWit)**: `m/49'/0'/0'/0` - P2SH-wrapped SegWit (starting with `3...`)
+  - **BIP84 (Native SegWit)**: `m/84'/0'/0'/0` - Bech32 addresses (starting with `bc1...`)
+- **Comprehensive Analysis**: For each address, displays:
+  - Current balance
+  - Total received amount
+  - Total sent amount
+  - Transaction count
+  - Derivation path
+
+### Transaction History
+- **Chronological Display**: Shows all transactions sorted by date (YYYY-MM-DD format)
+- **Running Balance**: Calculates and displays balance after each transaction
+- **Transaction Types**: Identifies received, sent, and self-transfer transactions
+- **Detailed Statistics**:
+  - Total received amount and count
+  - Total sent amount and count
+  - Transaction confirmation status
+
+### Architecture
+- **Modular Design**: Organized into separate packages for easy extension
+  - `types/`: Common interfaces and data structures
+  - `bitcoin/`: Bitcoin-specific implementation (derivation, API, analysis)
+  - Ready for additional blockchain support (e.g., Ethereum)
+- **Testable**: Comprehensive test suite with network tests using known mnemonic
+- **Public API Integration**: Uses Blockstream.info API with built-in rate limiting
+
+## Installation
+
+```bash
+# Clone or download the project
+cd btcphrasechecker
+
+# Download dependencies
+go mod download
+
+# Build
+go build -o btcphrasechecker
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Check wallet with mnemonic only
+./btcphrasechecker -mnemonic "your twelve or twenty four word mnemonic phrase here"
+
+# With optional passphrase
+./btcphrasechecker -mnemonic "your mnemonic phrase" -passphrase "your passphrase"
+
+# Customize number of addresses to check (default: 20)
+./btcphrasechecker -mnemonic "your mnemonic" -count 50
+```
+
+### Example Output
+
+```
+Bitcoin Wallet Analysis
+======================
+
+Checking BIP44 (Legacy): m/44'/0'/0'/0 - P2PKH addresses (1...)
+-----------------------------------------------------------
+  1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA
+    Path:     m/44'/0'/0'/0/0
+    Balance:  0.00000000 BTC
+    Received: 0.01146203 BTC
+    Sent:     0.01146203 BTC
+    Txs:      46
+
+Checking BIP49 (SegWit): m/49'/0'/0'/0 - P2SH-wrapped SegWit (3...)
+-----------------------------------------------------------
+  37VucYSaXLCAsxYyAPfbSi9eh4iEcbShgf
+    Path:     m/49'/0'/0'/0/0
+    Balance:  0.00000000 BTC
+    Received: 0.06783787 BTC
+    Sent:     0.06783787 BTC
+    Txs:      22
+
+Checking BIP84 (Native SegWit): m/84'/0'/0'/0 - Bech32 addresses (bc1...)
+-----------------------------------------------------------
+  bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu
+    Path:     m/84'/0'/0'/0/0
+    Balance:  0.00000000 BTC
+    Received: 0.04021550 BTC
+    Sent:     0.04021550 BTC
+    Txs:      166
+
+Fetching transaction history...
+
+======================
+Summary
+======================
+Total Balance:        0.00000000 BTC
+Total Received:       0.16710427 BTC (94 transactions)
+Total Sent:           0.16710427 BTC (91 transactions)
+Total Transactions:   360
+Active Addresses:     44
+
+Active Addresses Summary:
+-----------------------------------------------------------
+  1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA
+    Path:     m/44'/0'/0'/0/0
+    Balance:  0.00000000 BTC
+    Received: 0.01146203 BTC
+    Sent:     0.01146203 BTC
+    Txs:      46
+
+======================
+Transaction History
+======================
+Date                 Type         Confirmed  Amount (BTC)    Balance (BTC)  TxID
+---------------------------------------------------------------------------------------------------------------------------
+2014-11-09 03:31:39  + Received   Yes          0.00130000      0.00130000  d6f136091b72cb4f...
+2014-11-18 07:42:59  - Sent       Yes          0.00130000      0.00000000  f0ac3836d27b2914...
+2015-02-13 04:23:20  + Received   Yes          0.00016924      0.00016924  762ff05a44abf82e...
+...
+```
+
+## Testing
+
+The project includes a comprehensive test suite that uses the well-known test mnemonic:
+
+```
+abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about
+```
+
+### Run Tests
+
+```bash
+# Run all tests
+go test ./...
+
+# Run tests with verbose output
+go test -v ./...
+
+# Run specific test
+go test -v ./bitcoin -run TestDeriveAddresses
+
+# Run with network timeout (tests make real API calls)
+go test ./... -timeout 5m
+```
+
+### Test Coverage
+
+- **Derivation Tests**: Verifies correct address generation for all BIP standards
+- **API Tests**: Tests Blockstream API integration with real network calls
+- **Integration Tests**: End-to-end wallet analysis with the test mnemonic
+- **Passphrase Tests**: Validates different seeds from different passphrases
+- **Known Address Tests**: Validates against known good addresses
+
+## Project Structure
+
+```
+btcphrasechecker/
+├── main.go                  # Main entry point and CLI handling
+├── main_test.go             # Integration tests
+├── go.mod                   # Go module dependencies
+├── README.md                # This file
+│
+├── types/
+│   └── types.go            # Common types and interfaces
+│
+└── bitcoin/
+    ├── derivation.go       # BIP32/44/49/84 address derivation
+    ├── derivation_test.go  # Derivation tests
+    ├── api.go              # Blockstream API client
+    ├── api_test.go         # API tests
+    └── analyzer.go         # Wallet analysis logic
+```
+
+## Extensibility
+
+The codebase is designed to be easily extensible for additional blockchain support:
+
+1. **Add New Chain**: Implement the `ChainAnalyzer` interface in `types/types.go`
+2. **Create Package**: Add a new package (e.g., `ethereum/`) with chain-specific logic
+3. **Update Main**: Add chain selection logic in `main.go`
+
+Example interface:
+```go
+type ChainAnalyzer interface {
+    DeriveAddresses(seed []byte, count int) ([]AddressInfo, error)
+    GetAddressInfo(address string) (balance, txCount uint64, received, sent uint64, err error)
+    GetTransactions(address string) ([]Transaction, error)
+    GetChain() Chain
+}
+```
+
+## Security Notes
+
+- **Never share your mnemonic phrase** - This tool is for authorized wallet analysis only
+- **Read-only**: This tool only reads blockchain data; it cannot spend funds
+- **Public API**: Uses Blockstream.info public API which may log requests
+- **Privacy**: For maximum privacy, consider using a VPN or running your own Bitcoin node with API
+- **Rate Limiting**: 100ms delay between requests to avoid API throttling
+- **No Key Export**: Private keys are never exposed or stored
+
+## Dependencies
+
+- `github.com/tyler-smith/go-bip39` - BIP39 mnemonic implementation
+- `github.com/btcsuite/btcd` - Bitcoin library suite including:
+  - Address generation and encoding
+  - BIP32 HD key derivation
+  - Script building for P2SH-wrapped SegWit
+
+## Development
+
+### Building
+
+```bash
+go build -o btcphrasechecker
+```
+
+### Testing
+
+```bash
+# Run tests
+go test ./...
+
+# Run with coverage
+go test -cover ./...
+
+# Run with race detection
+go test -race ./...
+```
+
+### Code Quality
+
+```bash
+# Format code
+go fmt ./...
+
+# Lint code (requires golangci-lint)
+golangci-lint run
+
+# Vet code
+go vet ./...
+```
+
+## Future Enhancements
+
+- [ ] Ethereum support
+- [ ] Bitcoin testnet support
+- [ ] Custom derivation paths
+- [ ] Export to CSV/JSON
+- [ ] Local Bitcoin Core RPC support
+- [ ] UTXO tracking
+- [ ] Multi-signature wallet support
+- [ ] Hardware wallet integration
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please ensure:
+- All tests pass
+- Code is formatted with `go fmt`
+- New features include tests
+- Security best practices are followed
--- a/btcphrasechecker/bitcoin/analyzer.go
+++ b/btcphrasechecker/bitcoin/analyzer.go
@@ -0,0 +1,209 @@
+package bitcoin
+
+import (
+	"fmt"
+	"sort"
+	"time"
+
+	"btcphrasechecker/types"
+)
+
+// Analyzer implements the ChainAnalyzer interface for Bitcoin
+type Analyzer struct {
+	addressCount int
+}
+
+// NewAnalyzer creates a new Bitcoin analyzer
+func NewAnalyzer(addressCount int) *Analyzer {
+	return &Analyzer{
+		addressCount: addressCount,
+	}
+}
+
+// DeriveAddresses derives Bitcoin addresses from seed
+func (a *Analyzer) DeriveAddresses(seed []byte, count int) ([]types.AddressInfo, error) {
+	return DeriveAddresses(seed, count)
+}
+
+// GetAddressInfo fetches address information
+func (a *Analyzer) GetAddressInfo(address string) (balance, txCount uint64, received, sent uint64, err error) {
+	return GetAddressInfo(address)
+}
+
+// GetTransactions fetches transactions for an address
+func (a *Analyzer) GetTransactions(address string) ([]types.Transaction, error) {
+	return GetTransactions(address)
+}
+
+// GetChain returns the chain type
+func (a *Analyzer) GetChain() types.Chain {
+	return types.ChainBitcoin
+}
+
+// AnalyzeWallet performs comprehensive wallet analysis
+func AnalyzeWallet(seed []byte, addressCount int, verbose bool) (*types.WalletSummary, error) {
+	summary := &types.WalletSummary{
+		ActiveAddresses:    make([]types.AddressInfo, 0),
+		TransactionHistory: make([]types.TransactionDetail, 0),
+	}
+
+	// Derive all addresses
+	addresses, err := DeriveAddresses(seed, addressCount)
+	if err != nil {
+		return nil, err
+	}
+
+	if verbose {
+		fmt.Println("Bitcoin Wallet Analysis")
+		fmt.Println("======================")
+		fmt.Println()
+	}
+
+	// Check each derivation path
+	pathStats := make(map[string]struct {
+		count    int
+		received uint64
+		sent     uint64
+	})
+
+	for _, pathInfo := range StandardPaths {
+		if verbose {
+			fmt.Printf("Checking %s: %s - %s\n", pathInfo.Name, pathInfo.Path, pathInfo.Desc)
+			fmt.Println("-----------------------------------------------------------")
+		}
+
+		pathAddresses := filterByPath(addresses, pathInfo.Path)
+
+		for _, addr := range pathAddresses {
+			balance, txCount, received, sent, err := GetAddressInfo(addr.Address)
+			if err != nil {
+				continue
+			}
+
+			addr.Balance = balance
+			addr.TxCount = int(txCount)
+			addr.Received = received
+			addr.Sent = sent
+
+			if txCount > 0 {
+				if verbose {
+					fmt.Printf("  %s\n", addr.Address)
+					fmt.Printf("    Path: %s\n", addr.Path)
+					fmt.Printf("    Balance: %.8f BTC\n", float64(balance)/100000000.0)
+					fmt.Printf("    Received: %.8f BTC\n", float64(received)/100000000.0)
+					fmt.Printf("    Sent: %.8f BTC\n", float64(sent)/100000000.0)
+					fmt.Printf("    Transactions: %d\n", txCount)
+				}
+
+				summary.TotalBalance += balance
+				summary.TotalReceived += received
+				summary.TotalSent += sent
+				summary.TotalTxCount += int(txCount)
+				summary.ActiveAddresses = append(summary.ActiveAddresses, addr)
+
+				// Update path stats
+				ps := pathStats[pathInfo.Path]
+				ps.count++
+				ps.received += received
+				ps.sent += sent
+				pathStats[pathInfo.Path] = ps
+			}
+
+			// Rate limiting
+			time.Sleep(100 * time.Millisecond)
+		}
+
+		if verbose {
+			fmt.Println()
+		}
+	}
+
+	return summary, nil
+}
+
+// FetchTransactionHistory fetches and processes all transactions for active addresses
+func FetchTransactionHistory(summary *types.WalletSummary) error {
+	var allTransactions []types.TransactionDetail
+	receiveTxMap := make(map[string]bool)
+	sendTxMap := make(map[string]bool)
+
+	for _, addr := range summary.ActiveAddresses {
+		if addr.TxCount == 0 {
+			continue
+		}
+
+		txs, err := GetTransactions(addr.Address)
+		if err != nil {
+			continue
+		}
+
+		for _, tx := range txs {
+			txType := "self"
+			amount := uint64(0)
+
+			if tx.Received > 0 && tx.Sent == 0 {
+				txType = "received"
+				amount = tx.Received
+				receiveTxMap[tx.TxID] = true
+			} else if tx.Sent > 0 && tx.Received == 0 {
+				txType = "sent"
+				amount = tx.Sent
+				sendTxMap[tx.TxID] = true
+			} else if tx.Received > 0 && tx.Sent > 0 {
+				txType = "self"
+				amount = tx.Received
+			}
+
+			detail := types.TransactionDetail{
+				TxID:        tx.TxID,
+				Time:        tx.Time,
+				BlockHeight: tx.BlockHeight,
+				Confirmed:   tx.Confirmed,
+				Type:        txType,
+				Amount:      amount,
+				Address:     addr.Address,
+			}
+
+			allTransactions = append(allTransactions, detail)
+		}
+
+		// Rate limiting
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	// Sort by time (oldest first)
+	sort.Slice(allTransactions, func(i, j int) bool {
+		return allTransactions[i].Time.Before(allTransactions[j].Time)
+	})
+
+	// Calculate running balance
+	balance := uint64(0)
+	for i := range allTransactions {
+		tx := &allTransactions[i]
+		if tx.Type == "received" {
+			balance += tx.Amount
+		} else if tx.Type == "sent" {
+			if balance >= tx.Amount {
+				balance -= tx.Amount
+			}
+		}
+		tx.Balance = balance
+	}
+
+	summary.TransactionHistory = allTransactions
+	summary.ReceiveTxCount = len(receiveTxMap)
+	summary.SendTxCount = len(sendTxMap)
+
+	return nil
+}
+
+// filterByPath filters addresses by derivation path prefix
+func filterByPath(addresses []types.AddressInfo, pathPrefix string) []types.AddressInfo {
+	var filtered []types.AddressInfo
+	for _, addr := range addresses {
+		if len(addr.Path) >= len(pathPrefix) && addr.Path[:len(pathPrefix)] == pathPrefix {
+			filtered = append(filtered, addr)
+		}
+	}
+	return filtered
+}
--- a/btcphrasechecker/bitcoin/api.go
+++ b/btcphrasechecker/bitcoin/api.go
@@ -0,0 +1,161 @@
+package bitcoin
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"btcphrasechecker/types"
+)
+
+const (
+	// API base URL (using blockstream.info)
+	apiBaseURL = "https://blockstream.info/api"
+)
+
+// BlockstreamTransaction represents a transaction from Blockstream API
+type BlockstreamTransaction struct {
+	Txid   string `json:"txid"`
+	Status struct {
+		Confirmed   bool   `json:"confirmed"`
+		BlockHeight int    `json:"block_height"`
+		BlockTime   int64  `json:"block_time"`
+	} `json:"status"`
+	Vin []struct {
+		Txid    string `json:"txid"`
+		Vout    int    `json:"vout"`
+		Prevout struct {
+			Scriptpubkey        string `json:"scriptpubkey"`
+			ScriptpubkeyAddress string `json:"scriptpubkey_address"`
+			Value               uint64 `json:"value"`
+		} `json:"prevout"`
+	} `json:"vin"`
+	Vout []struct {
+		Scriptpubkey        string `json:"scriptpubkey"`
+		ScriptpubkeyAddress string `json:"scriptpubkey_address"`
+		Value               uint64 `json:"value"`
+	} `json:"vout"`
+	Fee uint64 `json:"fee"`
+}
+
+// GetAddressInfo fetches address information from Blockstream API
+func GetAddressInfo(address string) (balance, txCount uint64, received, sent uint64, err error) {
+	url := fmt.Sprintf("%s/address/%s", apiBaseURL, address)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return 0, 0, 0, 0, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	var addrData struct {
+		ChainStats struct {
+			FundedTxoSum uint64 `json:"funded_txo_sum"`
+			SpentTxoSum  uint64 `json:"spent_txo_sum"`
+			TxCount      int    `json:"tx_count"`
+		} `json:"chain_stats"`
+	}
+
+	if err := json.Unmarshal(body, &addrData); err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	balance = addrData.ChainStats.FundedTxoSum - addrData.ChainStats.SpentTxoSum
+	txCount = uint64(addrData.ChainStats.TxCount)
+	received = addrData.ChainStats.FundedTxoSum
+	sent = addrData.ChainStats.SpentTxoSum
+
+	return balance, txCount, received, sent, nil
+}
+
+// GetTransactions fetches all transactions for an address
+func GetTransactions(address string) ([]types.Transaction, error) {
+	url := fmt.Sprintf("%s/address/%s/txs", apiBaseURL, address)
+
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	var bsTxs []BlockstreamTransaction
+	if err := json.Unmarshal(body, &bsTxs); err != nil {
+		return nil, err
+	}
+
+	// Convert to common transaction format
+	var transactions []types.Transaction
+	for _, bsTx := range bsTxs {
+		tx := convertTransaction(bsTx, address)
+		transactions = append(transactions, tx)
+	}
+
+	return transactions, nil
+}
+
+// convertTransaction converts Blockstream transaction to common format
+func convertTransaction(bsTx BlockstreamTransaction, forAddress string) types.Transaction {
+	tx := types.Transaction{
+		TxID:        bsTx.Txid,
+		BlockHeight: bsTx.Status.BlockHeight,
+		Confirmed:   bsTx.Status.Confirmed,
+		Fee:         bsTx.Fee,
+	}
+
+	if bsTx.Status.BlockTime > 0 {
+		tx.Time = time.Unix(bsTx.Status.BlockTime, 0)
+	}
+
+	// Calculate received and sent amounts for this address
+	var received, sent uint64
+	addressSet := make(map[string]bool)
+
+	// Check inputs (sent from address)
+	for _, vin := range bsTx.Vin {
+		if vin.Prevout.ScriptpubkeyAddress == forAddress {
+			sent += vin.Prevout.Value
+		}
+		addressSet[vin.Prevout.ScriptpubkeyAddress] = true
+	}
+
+	// Check outputs (received by address)
+	for _, vout := range bsTx.Vout {
+		if vout.ScriptpubkeyAddress == forAddress {
+			received += vout.Value
+		}
+		addressSet[vout.ScriptpubkeyAddress] = true
+	}
+
+	tx.Received = received
+	tx.Sent = sent
+	tx.NetChange = int64(received) - int64(sent)
+
+	// Collect all unique addresses
+	for addr := range addressSet {
+		if addr != "" && addr != forAddress {
+			tx.Addresses = append(tx.Addresses, addr)
+		}
+	}
+
+	return tx
+}
--- a/btcphrasechecker/bitcoin/api_test.go
+++ b/btcphrasechecker/bitcoin/api_test.go
@@ -0,0 +1,72 @@
+package bitcoin
+
+import (
+	"testing"
+)
+
+func TestGetAddressInfo(t *testing.T) {
+	// Test with a known address from the test mnemonic
+	testAddress := "1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA"
+
+	balance, txCount, received, sent, err := GetAddressInfo(testAddress)
+	if err != nil {
+		t.Fatalf("GetAddressInfo failed: %v", err)
+	}
+
+	// This address has been used in tests, so it should have transactions
+	if txCount == 0 {
+		t.Log("Warning: Test address has no transactions. This might be expected if blockchain state changed.")
+	}
+
+	// Balance should equal received - sent
+	expectedBalance := received - sent
+	if balance != expectedBalance {
+		t.Errorf("Balance mismatch: balance=%d, received=%d, sent=%d, expected=%d",
+			balance, received, sent, expectedBalance)
+	}
+
+	t.Logf("Address: %s", testAddress)
+	t.Logf("Balance: %d satoshis (%.8f BTC)", balance, float64(balance)/100000000.0)
+	t.Logf("Received: %d satoshis", received)
+	t.Logf("Sent: %d satoshis", sent)
+	t.Logf("Transactions: %d", txCount)
+}
+
+func TestGetTransactions(t *testing.T) {
+	// Test with a known address from the test mnemonic
+	testAddress := "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu"
+
+	txs, err := GetTransactions(testAddress)
+	if err != nil {
+		t.Fatalf("GetTransactions failed: %v", err)
+	}
+
+	t.Logf("Found %d transactions for address %s", len(txs), testAddress)
+
+	// Verify transaction structure
+	for i, tx := range txs {
+		if tx.TxID == "" {
+			t.Errorf("Transaction %d has empty TxID", i)
+		}
+
+		if tx.Time.IsZero() && tx.Confirmed {
+			t.Errorf("Transaction %d is confirmed but has zero time", i)
+		}
+
+		// At least one of Received or Sent should be non-zero
+		if tx.Received == 0 && tx.Sent == 0 {
+			t.Logf("Warning: Transaction %d has zero received and sent amounts", i)
+		}
+
+		t.Logf("  Tx %d: %s, Received: %d, Sent: %d, NetChange: %d, Time: %s",
+			i, tx.TxID[:16], tx.Received, tx.Sent, tx.NetChange, tx.Time.Format("2006-01-02"))
+	}
+}
+
+func TestGetAddressInfoInvalidAddress(t *testing.T) {
+	// Test with an invalid address
+	_, _, _, _, err := GetAddressInfo("invalid_address")
+	if err == nil {
+		t.Error("Expected error for invalid address, got nil")
+	}
+}
--- a/btcphrasechecker/bitcoin/derivation.go
+++ b/btcphrasechecker/bitcoin/derivation.go
@@ -0,0 +1,148 @@
+package bitcoin
+
+import (
+	"fmt"
+
+	"btcphrasechecker/types"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/btcutil/hdkeychain"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/btcsuite/btcd/txscript"
+)
+
+// DerivationPath represents a BIP derivation path configuration
+type DerivationPath struct {
+	Name    string
+	Path    string
+	Purpose uint32
+	Desc    string
+}
+
+// Standard Bitcoin derivation paths
+var StandardPaths = []DerivationPath{
+	{
+		Name:    "BIP44 (Legacy)",
+		Path:    "m/44'/0'/0'/0",
+		Purpose: 44,
+		Desc:    "P2PKH addresses (1...)",
+	},
+	{
+		Name:    "BIP49 (SegWit)",
+		Path:    "m/49'/0'/0'/0",
+		Purpose: 49,
+		Desc:    "P2SH-wrapped SegWit (3...)",
+	},
+	{
+		Name:    "BIP84 (Native SegWit)",
+		Path:    "m/84'/0'/0'/0",
+		Purpose: 84,
+		Desc:    "Bech32 addresses (bc1...)",
+	},
+}
+
+// DeriveAddresses derives Bitcoin addresses from a seed for all standard paths
+func DeriveAddresses(seed []byte, addressCount int) ([]types.AddressInfo, error) {
+	masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create master key: %w", err)
+	}
+
+	var allAddresses []types.AddressInfo
+
+	for _, pathInfo := range StandardPaths {
+		addresses, err := derivePathAddresses(masterKey, pathInfo, addressCount)
+		if err != nil {
+			return nil, err
+		}
+		allAddresses = append(allAddresses, addresses...)
+	}
+
+	return allAddresses, nil
+}
+
+// derivePathAddresses derives addresses for a specific derivation path
+func derivePathAddresses(masterKey *hdkeychain.ExtendedKey, pathInfo DerivationPath, count int) ([]types.AddressInfo, error) {
+	var addresses []types.AddressInfo
+
+	// Derive base path: m/purpose'/coin_type'/account'/change
+	// For Bitcoin: coin_type = 0, account = 0, change = 0 (external addresses)
+	key := masterKey
+	key, _ = key.Derive(hdkeychain.HardenedKeyStart + pathInfo.Purpose)
+	key, _ = key.Derive(hdkeychain.HardenedKeyStart + 0) // coin_type = 0 for Bitcoin
+	key, _ = key.Derive(hdkeychain.HardenedKeyStart + 0) // account = 0
+	key, _ = key.Derive(0)                               // change = 0 (external)
+
+	// Derive individual addresses
+	for i := uint32(0); i < uint32(count); i++ {
+		childKey, err := key.Derive(i)
+		if err != nil {
+			continue
+		}
+
+		pubKey, err := childKey.ECPubKey()
+		if err != nil {
+			continue
+		}
+
+		pubKeyBytes := pubKey.SerializeCompressed()
+		address, err := deriveAddress(pubKeyBytes, pathInfo.Purpose)
+		if err != nil {
+			continue
+		}
+
+		addresses = append(addresses, types.AddressInfo{
+			Address: address,
+			Path:    fmt.Sprintf("%s/%d", pathInfo.Path, i),
+			Chain:   types.ChainBitcoin,
+		})
+	}
+
+	return addresses, nil
+}
+
+// deriveAddress creates an address from a public key based on the purpose
+func deriveAddress(pubKeyBytes []byte, purpose uint32) (string, error) {
+
+	switch purpose {
+	case 44:
+		// Legacy P2PKH
+		addr, err := btcutil.NewAddressPubKey(pubKeyBytes, &chaincfg.MainNetParams)
+		if err != nil {
+			return "", err
+		}
+		return addr.EncodeAddress(), nil
+
+	case 49:
+		// P2SH-wrapped SegWit (BIP49)
+		// Create witness program for P2WPKH
+		pubKeyHash := btcutil.Hash160(pubKeyBytes)
+		witnessProgram, err := txscript.NewScriptBuilder().
+			AddOp(txscript.OP_0).
+			AddData(pubKeyHash).
+			Script()
+		if err != nil {
+			return "", err
+		}
+		// Wrap witness program in P2SH
+		scriptAddr, err := btcutil.NewAddressScriptHash(witnessProgram, &chaincfg.MainNetParams)
+		if err != nil {
+			return "", err
+		}
+		return scriptAddr.EncodeAddress(), nil
+
+	case 84:
+		// Native SegWit (bech32)
+		addr, err := btcutil.NewAddressWitnessPubKeyHash(
+			btcutil.Hash160(pubKeyBytes),
+			&chaincfg.MainNetParams,
+		)
+		if err != nil {
+			return "", err
+		}
+		return addr.EncodeAddress(), nil
+
+	default:
+		return "", fmt.Errorf("unsupported purpose: %d", purpose)
+	}
+}
--- a/btcphrasechecker/bitcoin/derivation_test.go
+++ b/btcphrasechecker/bitcoin/derivation_test.go
@@ -0,0 +1,122 @@
+package bitcoin
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/btcutil/hdkeychain"
+	"github.com/btcsuite/btcd/chaincfg"
+	"github.com/tyler-smith/go-bip39"
+)
+
+const (
+	testMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+)
+
+func TestDeriveAddresses(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "")
+
+	addresses, err := DeriveAddresses(seed, 5)
+	if err != nil {
+		t.Fatalf("DeriveAddresses failed: %v", err)
+	}
+
+	// We expect 5 addresses per path * 3 paths = 15 addresses
+	expectedCount := 5 * len(StandardPaths)
+	if len(addresses) != expectedCount {
+		t.Errorf("Expected %d addresses, got %d", expectedCount, len(addresses))
+	}
+
+	// Test known addresses for the test mnemonic
+	expectedAddresses := map[string]string{
+		"m/44'/0'/0'/0/0": "1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA",
+		"m/84'/0'/0'/0/0": "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu",
+	}
+
+	addressMap := make(map[string]string)
+	for _, addr := range addresses {
+		addressMap[addr.Path] = addr.Address
+	}
+
+	for path, expectedAddr := range expectedAddresses {
+		if actualAddr, exists := addressMap[path]; !exists {
+			t.Errorf("Address for path %s not found", path)
+		} else if actualAddr != expectedAddr {
+			t.Errorf("Address mismatch for path %s: expected %s, got %s", path, expectedAddr, actualAddr)
+		}
+	}
+}
+
+func TestDerivePathAddresses(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "")
+	masterKey, err := hdkeychain.NewMaster(seed, &chaincfg.MainNetParams)
+	if err != nil {
+		t.Fatalf("Failed to create master key: %v", err)
+	}
+
+	tests := []struct {
+		path            DerivationPath
+		addressIndex    int
+		expectedAddress string
+	}{
+		{
+			path:            StandardPaths[0], // BIP44
+			addressIndex:    0,
+			expectedAddress: "1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA",
+		},
+		{
+			path:            StandardPaths[1], // BIP49
+			addressIndex:    0,
+			expectedAddress: "37VucYSaXLCAsxYyAPfbSi9eh4iEcbShgf",
+		},
+		{
+			path:            StandardPaths[2], // BIP84
+			addressIndex:    0,
+			expectedAddress: "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.path.Name, func(t *testing.T) {
+			addresses, err := derivePathAddresses(masterKey, tt.path, 5)
+			if err != nil {
+				t.Fatalf("derivePathAddresses failed: %v", err)
+			}
+
+			if len(addresses) != 5 {
+				t.Errorf("Expected 5 addresses, got %d", len(addresses))
+			}
+
+			if addresses[tt.addressIndex].Address != tt.expectedAddress {
+				t.Errorf("Address mismatch: expected %s, got %s",
+					tt.expectedAddress, addresses[tt.addressIndex].Address)
+			}
+		})
+	}
+}
+
+func TestDeriveAddressesWithPassphrase(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "TREZOR")
+
+	addresses, err := DeriveAddresses(seed, 1)
+	if err != nil {
+		t.Fatalf("DeriveAddresses failed: %v", err)
+	}
+
+	// With passphrase, addresses should be different
+	if len(addresses) == 0 {
+		t.Error("Expected addresses to be generated")
+	}
+
+	// The first BIP44 address with "TREZOR" passphrase should be different
+	addressMap := make(map[string]string)
+	for _, addr := range addresses {
+		addressMap[addr.Path] = addr.Address
+	}
+
+	// Should NOT match the address without passphrase
+	if addr, exists := addressMap["m/44'/0'/0'/0/0"]; exists {
+		if addr == "1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA" {
+			t.Error("Address should be different with passphrase")
+		}
+	}
+}
--- a/btcphrasechecker/go.mod
+++ b/btcphrasechecker/go.mod
@@ -0,0 +1,19 @@
+module btcphrasechecker
+
+go 1.21
+
+require (
+	github.com/btcsuite/btcd v0.24.0
+	github.com/btcsuite/btcd/btcutil v1.1.5
+	github.com/tyler-smith/go-bip39 v1.1.0
+)
+
+require (
+	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
+	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect
+	github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f // indirect
+	github.com/decred/dcrd/crypto/blake256 v1.0.1 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+)
--- a/btcphrasechecker/go.sum
+++ b/btcphrasechecker/go.sum
@@ -0,0 +1,119 @@
+github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
+github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
+github.com/btcsuite/btcd v0.22.0-beta.0.20220111032746-97732e52810c/go.mod h1:tjmYdS6MLJ5/s0Fj4DbLgSbDHbEqLJrtnHecBFkdz5M=
+github.com/btcsuite/btcd v0.23.5-0.20231215221805-96c9fd8078fd/go.mod h1:nm3Bko6zh6bWP60UxwoT5LzdGJsQJaPo6HjduXq9p6A=
+github.com/btcsuite/btcd v0.24.0 h1:gL3uHE/IaFj6fcZSu03SvqPMSx7s/dPzfpG/atRwWdo=
+github.com/btcsuite/btcd v0.24.0/go.mod h1:K4IDc1593s8jKXIF7yS7yCTSxrknB9z0STzc2j6XgE4=
+github.com/btcsuite/btcd/btcec/v2 v2.1.0/go.mod h1:2VzYrv4Gm4apmbVVsSq5bqf1Ec8v56E48Vt0Y/umPgA=
+github.com/btcsuite/btcd/btcec/v2 v2.1.3/go.mod h1:ctjw4H1kknNJmRN4iP1R7bTQ+v3GJkZBd6mui8ZsAZE=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
+github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
+github.com/btcsuite/btcd/btcutil v1.0.0/go.mod h1:Uoxwv0pqYWhD//tfTiipkxNfdhG9UrLwaeswfjfdF0A=
+github.com/btcsuite/btcd/btcutil v1.1.0/go.mod h1:5OapHB7A2hBBWLm48mmw4MOHNJCcUBTwmWH/0Jn8VHE=
+github.com/btcsuite/btcd/btcutil v1.1.5 h1:+wER79R5670vs/ZusMTF1yTcRYE5GUsFbdjdisflzM8=
+github.com/btcsuite/btcd/btcutil v1.1.5/go.mod h1:PSZZ4UitpLBWzxGd5VGOrLnmOjtPP/a6HaFo12zMs00=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 h1:59Kx4K6lzOW5w6nFlA0v5+lk/6sjybR934QNHSJZPTQ=
+github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
+github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f h1:bAs4lUbRJpnnkd9VhRV3jjAVU7DJVjMaK+IsvSeZvFo=
+github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
+github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
+github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
+github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
+github.com/btcsuite/goleveldb v1.0.0/go.mod h1:QiK9vBlgftBg6rWQIj6wFzbPfRjiykIEhBH4obrXJ/I=
+github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
+github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
+github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
+github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
+github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
+github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
+github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
+github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
+github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
+golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/btcphrasechecker/main.go
+++ b/btcphrasechecker/main.go
@@ -0,0 +1,143 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"btcphrasechecker/bitcoin"
+	"btcphrasechecker/types"
+
+	"github.com/tyler-smith/go-bip39"
+)
+
+const (
+	defaultAddressCount = 20
+)
+
+func main() {
+	mnemonic := flag.String("mnemonic", "", "BIP39 mnemonic phrase")
+	passphrase := flag.String("passphrase", "", "Optional passphrase")
+	addressCount := flag.Int("count", defaultAddressCount, "Number of addresses to check per derivation path")
+	chain := flag.String("chain", "bitcoin", "Blockchain to analyze (bitcoin)")
+	flag.Parse()
+
+	if *mnemonic == "" {
+		fmt.Println("Usage: btcphrasechecker -mnemonic \"your mnemonic phrase\" [-passphrase \"optional passphrase\"] [-count 20] [-chain bitcoin]")
+		os.Exit(1)
+	}
+
+	// Validate mnemonic
+	if !bip39.IsMnemonicValid(*mnemonic) {
+		fmt.Println("Error: Invalid mnemonic phrase")
+		os.Exit(1)
+	}
+
+	// Generate seed from mnemonic
+	seed := bip39.NewSeed(*mnemonic, *passphrase)
+
+	// Analyze based on chain
+	switch types.Chain(*chain) {
+	case types.ChainBitcoin:
+		if err := analyzeBitcoin(seed, *addressCount); err != nil {
+			fmt.Printf("Error analyzing Bitcoin wallet: %v\n", err)
+			os.Exit(1)
+		}
+	default:
+		fmt.Printf("Error: Unsupported chain '%s'\n", *chain)
+		os.Exit(1)
+	}
+}
+
+func analyzeBitcoin(seed []byte, addressCount int) error {
+	// Perform wallet analysis
+	summary, err := bitcoin.AnalyzeWallet(seed, addressCount, true)
+	if err != nil {
+		return err
+	}
+
+	// Fetch transaction history for active addresses
+	if len(summary.ActiveAddresses) > 0 {
+		fmt.Println("Fetching transaction history...")
+		fmt.Println()
+		if err := bitcoin.FetchTransactionHistory(summary); err != nil {
+			return err
+		}
+	}
+
+	// Display summary
+	displaySummary(summary)
+
+	// Display transaction history
+	if len(summary.TransactionHistory) > 0 {
+		displayTransactionHistory(summary)
+	}
+
+	return nil
+}
+
+func displaySummary(summary *types.WalletSummary) {
+	fmt.Println("======================")
+	fmt.Println("Summary")
+	fmt.Println("======================")
+	fmt.Printf("Total Balance:        %.8f BTC\n", float64(summary.TotalBalance)/100000000.0)
+	fmt.Printf("Total Received:       %.8f BTC (%d transactions)\n",
+		float64(summary.TotalReceived)/100000000.0,
+		summary.ReceiveTxCount)
+	fmt.Printf("Total Sent:           %.8f BTC (%d transactions)\n",
+		float64(summary.TotalSent)/100000000.0,
+		summary.SendTxCount)
+	fmt.Printf("Total Transactions:   %d\n", summary.TotalTxCount)
+	fmt.Printf("Active Addresses:     %d\n", len(summary.ActiveAddresses))
+	fmt.Println()
+
+	if len(summary.ActiveAddresses) > 0 {
+		fmt.Println("Active Addresses Summary:")
+		fmt.Println("-----------------------------------------------------------")
+		for _, addr := range summary.ActiveAddresses {
+			fmt.Printf("  %s\n", addr.Address)
+			fmt.Printf("    Path:     %s\n", addr.Path)
+			fmt.Printf("    Balance:  %.8f BTC\n", float64(addr.Balance)/100000000.0)
+			fmt.Printf("    Received: %.8f BTC\n", float64(addr.Received)/100000000.0)
+			fmt.Printf("    Sent:     %.8f BTC\n", float64(addr.Sent)/100000000.0)
+			fmt.Printf("    Txs:      %d\n", addr.TxCount)
+			fmt.Println()
+		}
+	}
+}
+
+func displayTransactionHistory(summary *types.WalletSummary) {
+	fmt.Println("======================")
+	fmt.Println("Transaction History")
+	fmt.Println("======================")
+	fmt.Printf("%-20s %-12s %-10s %-15s %-15s %s\n",
+		"Date", "Type", "Confirmed", "Amount (BTC)", "Balance (BTC)", "TxID")
+	fmt.Println("---------------------------------------------------------------------------------------------------------------------------")
+
+	for _, tx := range summary.TransactionHistory {
+		dateStr := tx.Time.Format("2006-01-02 15:04:05")
+		confirmedStr := "No"
+		if tx.Confirmed {
+			confirmedStr = "Yes"
+		}
+
+		typeSymbol := ""
+		switch tx.Type {
+		case "received":
+			typeSymbol = "+ Received"
+		case "sent":
+			typeSymbol = "- Sent"
+		case "self":
+			typeSymbol = "↔ Self"
+		}
+
+		fmt.Printf("%-20s %-12s %-10s %14.8f %14.8f %s\n",
+			dateStr,
+			typeSymbol,
+			confirmedStr,
+			float64(tx.Amount)/100000000.0,
+			float64(tx.Balance)/100000000.0,
+			tx.TxID[:16]+"...")
+	}
+	fmt.Println()
+}
--- a/btcphrasechecker/main_test.go
+++ b/btcphrasechecker/main_test.go
@@ -0,0 +1,236 @@
+package main
+
+import (
+	"testing"
+
+	"btcphrasechecker/bitcoin"
+	"btcphrasechecker/types"
+
+	"github.com/tyler-smith/go-bip39"
+)
+
+const (
+	testMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+)
+
+func TestBitcoinWalletAnalysis(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "")
+
+	summary, err := bitcoin.AnalyzeWallet(seed, 20, false)
+	if err != nil {
+		t.Fatalf("AnalyzeWallet failed: %v", err)
+	}
+
+	// Verify summary structure
+	if summary == nil {
+		t.Fatal("Summary is nil")
+	}
+
+	t.Logf("Total Balance: %.8f BTC", float64(summary.TotalBalance)/100000000.0)
+	t.Logf("Total Received: %.8f BTC", float64(summary.TotalReceived)/100000000.0)
+	t.Logf("Total Sent: %.8f BTC", float64(summary.TotalSent)/100000000.0)
+	t.Logf("Total Transactions: %d", summary.TotalTxCount)
+	t.Logf("Active Addresses: %d", len(summary.ActiveAddresses))
+
+	// Verify that received - sent = balance
+	expectedBalance := summary.TotalReceived - summary.TotalSent
+	if summary.TotalBalance != expectedBalance {
+		t.Errorf("Balance mismatch: balance=%d, received=%d, sent=%d, expected=%d",
+			summary.TotalBalance, summary.TotalReceived, summary.TotalSent, expectedBalance)
+	}
+
+	// Verify active addresses
+	for i, addr := range summary.ActiveAddresses {
+		if addr.Address == "" {
+			t.Errorf("Active address %d has empty address", i)
+		}
+		if addr.Path == "" {
+			t.Errorf("Active address %d has empty path", i)
+		}
+		if addr.Chain != types.ChainBitcoin {
+			t.Errorf("Active address %d has wrong chain: %s", i, addr.Chain)
+		}
+
+		// Verify address-level balance
+		addrExpectedBalance := addr.Received - addr.Sent
+		if addr.Balance != addrExpectedBalance {
+			t.Errorf("Address %s balance mismatch: balance=%d, received=%d, sent=%d",
+				addr.Address, addr.Balance, addr.Received, addr.Sent)
+		}
+
+		t.Logf("  Address %d: %s (Path: %s)", i, addr.Address, addr.Path)
+		t.Logf("    Balance: %.8f BTC, Received: %.8f BTC, Sent: %.8f BTC, Txs: %d",
+			float64(addr.Balance)/100000000.0,
+			float64(addr.Received)/100000000.0,
+			float64(addr.Sent)/100000000.0,
+			addr.TxCount)
+	}
+}
+
+func TestTransactionHistory(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "")
+
+	summary, err := bitcoin.AnalyzeWallet(seed, 20, false)
+	if err != nil {
+		t.Fatalf("AnalyzeWallet failed: %v", err)
+	}
+
+	if len(summary.ActiveAddresses) == 0 {
+		t.Skip("No active addresses found, skipping transaction history test")
+	}
+
+	err = bitcoin.FetchTransactionHistory(summary)
+	if err != nil {
+		t.Fatalf("FetchTransactionHistory failed: %v", err)
+	}
+
+	t.Logf("Total transactions in history: %d", len(summary.TransactionHistory))
+	t.Logf("Receive transactions: %d", summary.ReceiveTxCount)
+	t.Logf("Send transactions: %d", summary.SendTxCount)
+
+	// Verify transaction history
+	var prevTime int64
+	for i, tx := range summary.TransactionHistory {
+		if tx.TxID == "" {
+			t.Errorf("Transaction %d has empty TxID", i)
+		}
+
+		if tx.Time.IsZero() {
+			t.Logf("Warning: Transaction %d has zero time (might be unconfirmed)", i)
+		}
+
+		// Verify chronological order
+		currentTime := tx.Time.Unix()
+		if i > 0 && currentTime < prevTime {
+			t.Errorf("Transactions not in chronological order at index %d", i)
+		}
+		prevTime = currentTime
+
+		// Verify transaction type
+		if tx.Type != "received" && tx.Type != "sent" && tx.Type != "self" {
+			t.Errorf("Transaction %d has invalid type: %s", i, tx.Type)
+		}
+
+		if i < 10 { // Log first 10 transactions
+			t.Logf("  Tx %d: %s", i, tx.TxID[:16])
+			t.Logf("    Date: %s", tx.Time.Format("2006-01-02 15:04:05"))
+			t.Logf("    Type: %s, Amount: %.8f BTC, Balance: %.8f BTC",
+				tx.Type,
+				float64(tx.Amount)/100000000.0,
+				float64(tx.Balance)/100000000.0)
+		}
+	}
+
+	// Note: Final balance verification is complex due to self-transactions and
+	// transaction ordering across multiple addresses. The running balance is calculated
+	// per-address chronologically, but may not match the total wallet balance due to
+	// timing and internal transfers.
+	if len(summary.TransactionHistory) > 0 {
+		lastTx := summary.TransactionHistory[len(summary.TransactionHistory)-1]
+		t.Logf("Final tx balance: %.8f BTC, Total wallet balance: %.8f BTC",
+			float64(lastTx.Balance)/100000000.0,
+			float64(summary.TotalBalance)/100000000.0)
+	}
+}
+
+func TestKnownAddresses(t *testing.T) {
+	seed := bip39.NewSeed(testMnemonic, "")
+
+	addresses, err := bitcoin.DeriveAddresses(seed, 20)
+	if err != nil {
+		t.Fatalf("DeriveAddresses failed: %v", err)
+	}
+
+	// Map of known addresses for the test mnemonic
+	knownAddresses := map[string]string{
+		"m/44'/0'/0'/0/0": "1LqBGSKuX5yYUonjxT5qGfpUsXKYYWeabA",
+		"m/44'/0'/0'/0/1": "1Ak8PffB2meyfYnbXZR9EGfLfFZVpzJvQP",
+		"m/49'/0'/0'/0/0": "37VucYSaXLCAsxYyAPfbSi9eh4iEcbShgf",
+		"m/84'/0'/0'/0/0": "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu",
+		"m/84'/0'/0'/0/1": "bc1qnjg0jd8228aq7egyzacy8cys3knf9xvrerkf9g",
+	}
+
+	addressMap := make(map[string]string)
+	for _, addr := range addresses {
+		addressMap[addr.Path] = addr.Address
+	}
+
+	for path, expectedAddr := range knownAddresses {
+		actualAddr, exists := addressMap[path]
+		if !exists {
+			t.Errorf("Address for path %s not found", path)
+			continue
+		}
+		if actualAddr != expectedAddr {
+			t.Errorf("Address mismatch for path %s:\n  expected: %s\n  got:      %s",
+				path, expectedAddr, actualAddr)
+		} else {
+			t.Logf("✓ %s = %s", path, actualAddr)
+		}
+	}
+}
+
+func TestMnemonicValidation(t *testing.T) {
+	tests := []struct {
+		name     string
+		mnemonic string
+		valid    bool
+	}{
+		{
+			name:     "Valid 12-word mnemonic",
+			mnemonic: testMnemonic,
+			valid:    true,
+		},
+		{
+			name:     "Invalid mnemonic",
+			mnemonic: "invalid mnemonic phrase that should not work",
+			valid:    false,
+		},
+		{
+			name:     "Empty mnemonic",
+			mnemonic: "",
+			valid:    false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			valid := bip39.IsMnemonicValid(tt.mnemonic)
+			if valid != tt.valid {
+				t.Errorf("Expected mnemonic validity to be %v, got %v", tt.valid, valid)
+			}
+		})
+	}
+}
+
+func TestPassphraseSupport(t *testing.T) {
+	// Test that different passphrases generate different seeds
+	seed1 := bip39.NewSeed(testMnemonic, "")
+	seed2 := bip39.NewSeed(testMnemonic, "password123")
+
+	if string(seed1) == string(seed2) {
+		t.Error("Seeds with different passphrases should be different")
+	}
+
+	// Verify that addresses are different with different passphrases
+	addresses1, err := bitcoin.DeriveAddresses(seed1, 1)
+	if err != nil {
+		t.Fatalf("DeriveAddresses failed for seed1: %v", err)
+	}
+
+	addresses2, err := bitcoin.DeriveAddresses(seed2, 1)
+	if err != nil {
+		t.Fatalf("DeriveAddresses failed for seed2: %v", err)
+	}
+
+	if len(addresses1) == 0 || len(addresses2) == 0 {
+		t.Fatal("No addresses generated")
+	}
+
+	if addresses1[0].Address == addresses2[0].Address {
+		t.Error("Addresses should be different with different passphrases")
+	}
+
+	t.Logf("Without passphrase: %s", addresses1[0].Address)
+	t.Logf("With passphrase:    %s", addresses2[0].Address)
+}
--- a/btcphrasechecker/types/types.go
+++ b/btcphrasechecker/types/types.go
@@ -0,0 +1,67 @@
+package types
+
+import "time"
+
+// Chain represents a blockchain type
+type Chain string
+
+const (
+	ChainBitcoin  Chain = "bitcoin"
+	ChainEthereum Chain = "ethereum"
+)
+
+// AddressInfo contains information about a derived address
+type AddressInfo struct {
+	Address  string
+	Path     string
+	Balance  uint64
+	TxCount  int
+	Chain    Chain
+	Received uint64
+	Sent     uint64
+}
+
+// Transaction represents a blockchain transaction
+type Transaction struct {
+	TxID        string
+	Time        time.Time
+	BlockHeight int
+	Confirmed   bool
+	Received    uint64
+	Sent        uint64
+	Fee         uint64
+	NetChange   int64 // Can be negative
+	Addresses   []string
+}
+
+// TransactionDetail provides detailed transaction information
+type TransactionDetail struct {
+	TxID        string
+	Time        time.Time
+	BlockHeight int
+	Confirmed   bool
+	Type        string // "received", "sent", "self"
+	Amount      uint64
+	Balance     uint64 // Running balance after this tx
+	Address     string
+}
+
+// WalletSummary contains overall wallet statistics
+type WalletSummary struct {
+	TotalBalance      uint64
+	TotalReceived     uint64
+	TotalSent         uint64
+	TotalTxCount      int
+	ReceiveTxCount    int
+	SendTxCount       int
+	ActiveAddresses   []AddressInfo
+	TransactionHistory []TransactionDetail
+}
+
+// ChainAnalyzer defines the interface for blockchain analysis
+type ChainAnalyzer interface {
+	DeriveAddresses(seed []byte, count int) ([]AddressInfo, error)
+	GetAddressInfo(address string) (balance, txCount uint64, received, sent uint64, err error)
+	GetTransactions(address string) ([]Transaction, error)
+	GetChain() Chain
+}