⛏️ AlmaLinux Blockchain & Crypto Mining Complete Setup Guide

Ready to dive into the exciting world of blockchain and cryptocurrency on AlmaLinux? 🚀 Whether you’re interested in running blockchain nodes, developing DeFi applications, or exploring crypto mining, this comprehensive guide will transform your AlmaLinux system into a powerful blockchain workstation! ✨

Blockchain technology is revolutionizing finance, supply chains, gaming, and countless other industries. By setting up your own blockchain environment, you’re joining the cutting-edge of technological innovation! 🌟

🤔 Why Learn Blockchain on AlmaLinux?

Building blockchain solutions on AlmaLinux offers incredible advantages! 🎯

Essential Benefits:

• 🛡️ Enhanced Security - AlmaLinux’s enterprise-grade security for blockchain operations
• ⚡ High Performance - Optimized for demanding blockchain workloads
• 🔧 Full Control - Run your own nodes without relying on third parties
• 💰 Cost Effective - No monthly fees for cloud blockchain services
• 🌐 Network Participation - Contribute to decentralized networks
• 📈 Learning Opportunity - Understand blockchain technology deeply
• 🎨 Development Platform - Build your own blockchain applications
• 🔍 Privacy Protection - Keep your transactions and data private

🎯 What You Need Before Starting

Let’s make sure you’re ready for this blockchain adventure! ✅

System Requirements:

• ✅ AlmaLinux 8 or 9 (fresh installation recommended)
• ✅ Minimum 16GB RAM (32GB+ recommended for full nodes)
• ✅ 1TB+ SSD storage (blockchain data grows constantly!)
• ✅ High-speed internet connection (unlimited bandwidth preferred)
• ✅ Sudo/root access for system configuration
• ✅ Basic command line knowledge (we’ll guide you!)
• ✅ Understanding of blockchain basics (we’ll explain as we go!)

What We’ll Set Up:

• ✅ Bitcoin Core full node for network participation
• ✅ Ethereum development environment and node
• ✅ DeFi development tools and frameworks
• ✅ Crypto mining software and optimization
• ✅ Blockchain security and wallet management
• ✅ Web3 development environment

📝 Step 1: System Preparation and Security Hardening

Before diving into blockchain, let’s secure our system properly! Security is paramount in blockchain operations.

# Update system packages first
sudo dnf update -y

# Install essential development tools
sudo dnf groupinstall "Development Tools" -y
sudo dnf install -y \
    git \
    curl \
    wget \
    unzip \
    cmake \
    autoconf \
    automake \
    libtool \
    pkgconfig \
    boost-devel \
    openssl-devel \
    libevent-devel \
    miniupnpc-devel \
    zeromq-devel \
    sqlite-devel

Enhanced Security Configuration:

# Create dedicated blockchain user (security best practice)
sudo useradd -m -s /bin/bash blockchain
sudo usermod -aG wheel blockchain

# Set up firewall rules
sudo firewall-cmd --permanent --add-port=8333/tcp   # Bitcoin
sudo firewall-cmd --permanent --add-port=8332/tcp   # Bitcoin RPC
sudo firewall-cmd --permanent --add-port=30303/tcp  # Ethereum
sudo firewall-cmd --permanent --add-port=30303/udp  # Ethereum discovery
sudo firewall-cmd --permanent --add-port=8545/tcp   # Ethereum RPC
sudo firewall-cmd --reload

# Enable fail2ban for additional security
sudo dnf install -y epel-release
sudo dnf install -y fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

# Configure system limits for blockchain operations
cat >> /etc/security/limits.conf << 'EOF'
blockchain soft nofile 65536
blockchain hard nofile 65536
blockchain soft nproc 32768
blockchain hard nproc 32768
EOF

Create Secure Directory Structure:

# Create blockchain working directories
sudo mkdir -p /opt/blockchain/{bitcoin,ethereum,mining,wallets}
sudo mkdir -p /var/lib/blockchain/{data,logs}
sudo chown -R blockchain:blockchain /opt/blockchain /var/lib/blockchain

# Switch to blockchain user for operations
sudo su - blockchain
cd /opt/blockchain

🔧 Step 2: Bitcoin Core Full Node Setup

Let’s set up a Bitcoin Core full node! This allows you to participate in the Bitcoin network directly.

# Download Bitcoin Core (latest stable version)
cd /opt/blockchain/bitcoin
wget https://bitcoincore.org/bin/bitcoin-core-25.0/bitcoin-25.0-x86_64-linux-gnu.tar.gz
wget https://bitcoincore.org/bin/bitcoin-core-25.0/SHA256SUMS

# Verify download integrity (important for security!)
sha256sum -c SHA256SUMS 2>&1 | grep OK

# Extract Bitcoin Core
tar -xzf bitcoin-25.0-x86_64-linux-gnu.tar.gz
sudo cp bitcoin-25.0/bin/* /usr/local/bin/

# Verify installation
bitcoind --version

Configure Bitcoin Core:

# Create Bitcoin configuration directory
mkdir -p ~/.bitcoin

# Create optimized bitcoin.conf
cat > ~/.bitcoin/bitcoin.conf << 'EOF'
# Bitcoin Core Configuration for AlmaLinux

# Network settings
listen=1
maxconnections=125
maxuploadtarget=5000

# RPC settings (for local access only)
server=1
rpcuser=bitcoinrpc
rpcpassword=$(openssl rand -base64 32)
rpcallowip=127.0.0.1
rpcbind=127.0.0.1

# Performance optimizations
dbcache=4096
maxmempool=512
mempoolexpiry=168

# Logging
debug=0
shrinkdebugfile=1

# Pruning (optional, saves disk space)
# prune=50000

# Testnet (for safe testing, remove for mainnet)
# testnet=1
EOF

# Set secure permissions
chmod 600 ~/.bitcoin/bitcoin.conf

Create Bitcoin Service:

# Create systemd service file
sudo tee /etc/systemd/system/bitcoind.service << 'EOF'
[Unit]
Description=Bitcoin Core daemon
After=network.target
Wants=network.target

[Service]
Type=notify
ExecStart=/usr/local/bin/bitcoind -conf=/home/blockchain/.bitcoin/bitcoin.conf -datadir=/home/blockchain/.bitcoin
User=blockchain
Group=blockchain
KillMode=mixed
Restart=on-failure
RestartSec=5
TimeoutStartSec=infinity
TimeoutStopSec=600

# Process management
LimitNOFILE=128000
LimitNPROC=128000

# Security settings
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=false

[Install]
WantedBy=multi-user.target
EOF

# Enable and start Bitcoin service
sudo systemctl enable bitcoind
sudo systemctl start bitcoind

# Check status
sudo systemctl status bitcoind

Monitor Bitcoin Sync Progress:

# Check sync status (this will take several hours to days!)
bitcoin-cli getblockchaininfo

# Monitor sync progress script
cat > ~/bitcoin-monitor.sh << 'EOF'
#!/bin/bash
while true; do
    info=$(bitcoin-cli getblockchaininfo 2>/dev/null)
    if [ $? -eq 0 ]; then
        blocks=$(echo "$info" | jq -r '.blocks')
        headers=$(echo "$info" | jq -r '.headers')
        progress=$(echo "$info" | jq -r '.verificationprogress')
        percent=$(echo "$progress * 100" | bc -l | cut -d. -f1)
        echo "📊 Bitcoin sync: $blocks/$headers blocks ($percent% complete)"
    else
        echo "❌ Bitcoin node not responding"
    fi
    sleep 30
done
EOF

chmod +x ~/bitcoin-monitor.sh

🌟 Step 3: Ethereum Development Environment

Let’s set up a complete Ethereum development environment for building DeFi applications!

# Install Node.js (required for Ethereum tools)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc
nvm install --lts
nvm use --lts

Install Ethereum Development Tools:

# Install essential Ethereum tools
npm install -g \
    @ethereum/client \
    hardhat \
    truffle \
    ganache-cli \
    web3 \
    ethers \
    @openzeppelin/contracts

# Install Go (needed for Geth)
cd /opt/blockchain/ethereum
wget https://golang.org/dl/go1.21.1.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.1.linux-amd64.tar.gz

# Add Go to PATH
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

# Verify Go installation
go version

Install Geth (Ethereum Client):

# Clone and build Geth
git clone https://github.com/ethereum/go-ethereum.git
cd go-ethereum
make geth

# Copy geth binary
sudo cp build/bin/geth /usr/local/bin/

# Verify installation
geth version

Configure Ethereum Node:

# Create Ethereum data directory
mkdir -p ~/.ethereum

# Create Geth service
sudo tee /etc/systemd/system/geth.service << 'EOF'
[Unit]
Description=Ethereum Go client
After=network.target
Wants=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/geth --datadir /home/blockchain/.ethereum --http --http.addr 127.0.0.1 --http.port 8545 --http.api eth,net,web3,personal --ws --ws.addr 127.0.0.1 --ws.port 8546 --ws.api eth,net,web3,personal --maxpeers 50
User=blockchain
Group=blockchain
Restart=on-failure
RestartSec=5

# Security settings
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=full
ProtectHome=false

[Install]
WantedBy=multi-user.target
EOF

# Enable and start Geth
sudo systemctl enable geth
sudo systemctl start geth

# Check status
sudo systemctl status geth

✅ Step 4: DeFi Development Framework Setup

Let’s set up tools for developing decentralized finance applications!

# Create DeFi development workspace
mkdir -p ~/defi-projects
cd ~/defi-projects

# Create sample DeFi project with Hardhat
npx hardhat init

# Install essential DeFi libraries
npm install \
    @openzeppelin/contracts \
    @chainlink/contracts \
    @uniswap/v3-core \
    @uniswap/v3-periphery \
    ethers \
    web3 \
    @nomiclabs/hardhat-ethers \
    @nomiclabs/hardhat-waffle

Create Sample DeFi Smart Contract:

# Create a simple token contract
cat > contracts/MyDeFiToken.sol << 'EOF'
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

contract MyDeFiToken is ERC20, Ownable, Pausable {
    uint256 public constant MAX_SUPPLY = 1000000 * 10**18; // 1 million tokens

    constructor() ERC20("MyDeFi Token", "MDFI") {
        _mint(msg.sender, 100000 * 10**18); // Initial mint: 100k tokens
    }

    function mint(address to, uint256 amount) public onlyOwner {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override whenNotPaused {
        super._beforeTokenTransfer(from, to, amount);
    }
}
EOF

# Create deployment script
cat > scripts/deploy.js << 'EOF'
const { ethers } = require("hardhat");

async function main() {
    console.log("🚀 Deploying MyDeFi Token...");

    const MyDeFiToken = await ethers.getContractFactory("MyDeFiToken");
    const token = await MyDeFiToken.deploy();

    await token.deployed();

    console.log("✅ MyDeFi Token deployed to:", token.address);
    console.log("🎉 Initial supply minted to deployer");
}

main()
    .then(() => process.exit(0))
    .catch((error) => {
        console.error("❌ Deployment failed:", error);
        process.exit(1);
    });
EOF

# Configure Hardhat
cat > hardhat.config.js << 'EOF'
require("@nomiclabs/hardhat-waffle");
require("@nomiclabs/hardhat-ethers");

module.exports = {
    solidity: {
        version: "0.8.19",
        settings: {
            optimizer: {
                enabled: true,
                runs: 200
            }
        }
    },
    networks: {
        localhost: {
            url: "http://127.0.0.1:8545"
        },
        hardhat: {
            chainId: 1337
        }
    }
};
EOF

# Test the contract
npx hardhat compile
npx hardhat test

🌐 Step 5: Crypto Mining Software Setup

Let’s explore cryptocurrency mining options! Remember to always consider electricity costs and environmental impact.

# Create mining directory
mkdir -p /opt/blockchain/mining
cd /opt/blockchain/mining

CPU Mining with XMRig (Monero):

# Download XMRig (popular CPU miner)
wget https://github.com/xmrig/xmrig/releases/download/v6.20.0/xmrig-6.20.0-linux-x64.tar.gz
tar -xzf xmrig-6.20.0-linux-x64.tar.gz
cd xmrig-6.20.0

# Create mining configuration
cat > config.json << 'EOF'
{
    "api": {
        "id": null,
        "worker-id": null
    },
    "http": {
        "enabled": false,
        "host": "127.0.0.1",
        "port": 0,
        "access-token": null,
        "restricted": true
    },
    "autosave": true,
    "background": false,
    "colors": true,
    "title": true,
    "randomx": {
        "init": -1,
        "init-avx2": -1,
        "mode": "auto",
        "1gb-pages": false,
        "rdmsr": true,
        "wrmsr": true,
        "cache_qos": false,
        "numa": true,
        "scratchpad_prefetch_mode": 1
    },
    "cpu": {
        "enabled": true,
        "huge-pages": true,
        "huge-pages-jit": false,
        "hw-aes": null,
        "priority": null,
        "memory-pool": false,
        "yield": true,
        "max-threads-hint": 100,
        "asm": true,
        "argon2-impl": null,
        "argon2": [0, 1, 2, 3],
        "astrobwt": [0, 1, 2, 3],
        "cn": [
            [1, 0],
            [1, 2]
        ],
        "cn-heavy": [
            [1, 0]
        ],
        "cn-lite": [
            [1, 0],
            [1, 2]
        ],
        "cn-pico": [
            [2, 0],
            [2, 2]
        ],
        "rx": [0, 1, 2, 3],
        "rx/wow": [0, 1, 2, 3],
        "cn/0": false,
        "cn-lite/0": false,
        "rx/arq": "rx/wow",
        "rx/keva": "rx/wow"
    },
    "opencl": {
        "enabled": false,
        "cache": true,
        "loader": null,
        "platform": "AMD",
        "adl": true,
        "cn/0": false,
        "cn-lite/0": false
    },
    "cuda": {
        "enabled": false,
        "loader": null,
        "nvml": true,
        "cn/0": false,
        "cn-lite/0": false
    },
    "pools": [
        {
            "algo": null,
            "coin": null,
            "url": "pool.supportxmr.com:443",
            "user": "YOUR_MONERO_ADDRESS",
            "pass": "x",
            "rig-id": null,
            "nicehash": false,
            "keepalive": false,
            "enabled": true,
            "tls": true,
            "tls-fingerprint": null,
            "daemon": false,
            "socks5": null,
            "self-select": null,
            "submit-to-origin": false
        }
    ],
    "print-time": 60,
    "health-print-time": 60,
    "dmi": true,
    "retries": 5,
    "retry-pause": 5,
    "syslog": false,
    "tls": {
        "enabled": false,
        "protocols": null,
        "cert": null,
        "cert_key": null,
        "ciphers": null,
        "ciphersuites": null,
        "dhparam": null
    },
    "user-agent": null,
    "verbose": 0,
    "watch": true,
    "pause-on-battery": false,
    "pause-on-active": false
}
EOF

# Note: Replace "YOUR_MONERO_ADDRESS" with an actual Monero wallet address
echo "⚠️  Remember to replace 'YOUR_MONERO_ADDRESS' with your actual wallet address!"

GPU Mining Setup (if you have compatible GPU):

# Install NVIDIA drivers (if using NVIDIA GPU)
sudo dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
sudo dnf install -y cuda-toolkit

# For AMD GPUs, install ROCm
sudo dnf install -y rocm-dev rocm-opencl

# Install T-Rex miner for NVIDIA (Ethereum mining)
wget https://github.com/trex-miner/T-Rex/releases/download/0.26.8/t-rex-0.26.8-linux.tar.gz
tar -xzf t-rex-0.26.8-linux.tar.gz

# Create T-Rex configuration
cat > t-rex-config.json << 'EOF'
{
    "algorithm": "ethash",
    "workers": [
        {
            "worker": "YOUR_ETH_WALLET.AlmaLinux-Rig",
            "pool": "stratum1+tcp://eth-us-east1.nanopool.org:9999"
        }
    ],
    "intensity": 21,
    "gpu-report-interval": 30,
    "cpu-priority": 2,
    "log-path": "./logs",
    "protocol-dump": false,
    "no-color": false,
    "no-hashrate-report": false,
    "no-nvml": false,
    "pci-indexing": false,
    "exit-on-cuda-error": true,
    "exit-on-connection-lost": false,
    "reconnect-on-fail-shares": 10
}
EOF

echo "⚠️  Remember to replace 'YOUR_ETH_WALLET' with your actual Ethereum wallet address!"

🎮 Quick Examples - Blockchain Operations

Let’s create some practical examples you can use right away! 🚀

Example 1: Create and Test Ethereum Wallet

# Create new Ethereum wallet
cd ~/defi-projects
node -e "
const { Wallet } = require('ethers');
const wallet = Wallet.createRandom();
console.log('🔐 New Ethereum Wallet Created!');
console.log('Address:', wallet.address);
console.log('Private Key:', wallet.privateKey);
console.log('⚠️  KEEP YOUR PRIVATE KEY SAFE AND SECRET!');
console.log('💡 You can import this wallet into MetaMask or other wallets');
"

# Check Ethereum balance (example)
node -e "
const { ethers } = require('ethers');
const provider = new ethers.providers.JsonRpcProvider('http://localhost:8545');

async function checkBalance() {
    try {
        const balance = await provider.getBalance('YOUR_ADDRESS_HERE');
        console.log('💰 Balance:', ethers.utils.formatEther(balance), 'ETH');
    } catch (error) {
        console.log('❌ Error:', error.message);
    }
}

checkBalance();
"

Example 2: Bitcoin Transaction Monitoring

# Create Bitcoin monitoring script
cat > ~/bitcoin-tx-monitor.sh << 'EOF'
#!/bin/bash

echo "📊 Bitcoin Network Monitor"
echo "=========================="

# Network info
echo -e "\n🌐 Network Information:"
bitcoin-cli getnetworkinfo | jq -r '"Connections: " + (.connections | tostring)'
bitcoin-cli getblockchaininfo | jq -r '"Blocks: " + (.blocks | tostring) + " | Chain: " + .chain'

# Memory pool info
echo -e "\n💾 Memory Pool:"
bitcoin-cli getmempoolinfo | jq -r '"Transactions: " + (.size | tostring) + " | Size: " + (.bytes | tostring) + " bytes"'

# Recent transactions
echo -e "\n📝 Recent Transactions:"
bitcoin-cli listtransactions "*" 5 | jq -r '.[] | "Amount: " + (.amount | tostring) + " BTC | Confirmations: " + (.confirmations | tostring)'

echo -e "\nMonitoring completed at $(date)"
EOF

chmod +x ~/bitcoin-tx-monitor.sh

Example 3: DeFi Yield Farming Calculator

# Create yield calculation tool
cat > ~/yield-calculator.js << 'EOF'
const calculateYield = (principal, apr, compound_frequency, days) => {
    const rate = apr / 100;
    const n = compound_frequency; // compounds per year
    const t = days / 365; // time in years

    // Compound interest formula: A = P(1 + r/n)^(nt)
    const amount = principal * Math.pow((1 + rate/n), (n*t));
    const profit = amount - principal;
    const apy = (amount / principal - 1) * (365 / days) * 100;

    console.log(`💰 Yield Farming Calculator`);
    console.log(`==========================`);
    console.log(`💵 Principal: $${principal.toLocaleString()}`);
    console.log(`📈 APR: ${apr}%`);
    console.log(`⏰ Period: ${days} days`);
    console.log(`🔄 Compound: ${n}x per year`);
    console.log(`💎 Final Amount: $${amount.toLocaleString()}`);
    console.log(`🎯 Profit: $${profit.toLocaleString()}`);
    console.log(`⚡ APY: ${apy.toFixed(2)}%`);
};

// Example calculations
console.log(`🚀 DeFi Yield Examples:\n`);
calculateYield(10000, 12, 365, 365); // $10k at 12% APR, daily compound, 1 year
console.log(`\n`);
calculateYield(5000, 8.5, 12, 90);   // $5k at 8.5% APR, monthly compound, 90 days
EOF

node ~/yield-calculator.js

🚨 Fix Common Blockchain Problems

Even blockchain experts face challenges! Here are solutions to common issues: 💪

Problem 1: Bitcoin Node Won’t Sync

# Symptoms: Bitcoin node stuck at old blocks or not syncing
# Solution: Check network and restart with fresh peers

# Check current status
bitcoin-cli getblockchaininfo

# Clear peer connections
bitcoin-cli stop
sleep 5

# Remove peers.dat to get fresh connections
rm ~/.bitcoin/peers.dat

# Restart Bitcoin daemon
bitcoind -daemon

# Monitor new sync
tail -f ~/.bitcoin/debug.log | grep "UpdateTip"

Problem 2: Ethereum Node Out of Disk Space

# Symptoms: Ethereum sync fails due to insufficient storage
# Solution: Enable pruning and cleanup

# Stop Geth
sudo systemctl stop geth

# Start with pruning enabled (keeps only recent 128GB of data)
geth --datadir ~/.ethereum --syncmode "fast" --gcmode archive --cache 2048 --prune-ancient

# Or start fresh with light client (minimal storage)
rm -rf ~/.ethereum/geth
geth --datadir ~/.ethereum --syncmode "light"

# Monitor disk usage
df -h ~/.ethereum

Problem 3: Mining Performance Issues

# Symptoms: Low hashrate or mining software crashes
# Solution: Optimize system and mining configuration

# Check CPU temperature and throttling
sensors
cat /proc/cpuinfo | grep MHz

# Optimize CPU governor for performance
sudo cpupower frequency-set -g performance

# Increase system limits
echo 'vm.swappiness=1' | sudo tee -a /etc/sysctl.conf
echo 'vm.dirty_ratio=5' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Monitor mining performance
htop
nvidia-smi  # For NVIDIA GPUs
rocm-smi   # For AMD GPUs

# Restart mining with optimized settings
cd /opt/blockchain/mining/xmrig-6.20.0
./xmrig --config=config.json --threads=$(nproc)

Problem 4: Smart Contract Deployment Failures

# Symptoms: "out of gas" or transaction reverts
# Solution: Optimize gas settings and contract code

# Check gas estimation
cd ~/defi-projects
npx hardhat console

# In Hardhat console:
# const contract = await ethers.getContractFactory("MyDeFiToken");
# const gasEstimate = await contract.getDeployTransaction().estimateGas();
# console.log("Estimated gas:", gasEstimate.toString());

# Deploy with higher gas limit
npx hardhat run scripts/deploy.js --network localhost

# If still failing, check contract code for infinite loops
npx hardhat compile --show-stack-traces

Problem 5: Wallet Connection Issues

# Symptoms: Can't connect to wallet or send transactions
# Solution: Check RPC settings and permissions

# Test RPC connection
curl -X POST -H "Content-Type: application/json" \
     --data '{"jsonrpc":"2.0","method":"eth_accounts","params":[],"id":1}' \
     http://localhost:8545

# Check Geth logs for errors
sudo journalctl -u geth -f

# Restart with correct RPC settings
sudo systemctl stop geth
geth --datadir ~/.ethereum \
     --http --http.addr 0.0.0.0 --http.port 8545 \
     --http.api eth,net,web3,personal \
     --http.corsdomain "*" \
     --allow-insecure-unlock

# For Bitcoin RPC issues
bitcoin-cli -rpcconnect=127.0.0.1 -rpcport=8332 getblockchaininfo

📋 Blockchain Operations Commands Summary

Here’s your quick reference for blockchain operations! ⚡

💡 Pro Tips for Blockchain Success

Want to become a blockchain ninja? Here are expert secrets! 🥷

Tip 1: Automated Backup Strategy

# Create blockchain backup script
cat > ~/blockchain-backup.sh << 'EOF'
#!/bin/bash
# Blockchain Data Backup Script

BACKUP_DIR="$HOME/blockchain-backups/$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"

echo "🚀 Starting blockchain backup..."

# Backup Bitcoin wallet
if [ -f ~/.bitcoin/wallet.dat ]; then
    cp ~/.bitcoin/wallet.dat "$BACKUP_DIR/bitcoin-wallet.dat"
    echo "✅ Bitcoin wallet backed up"
fi

# Backup Ethereum keystore
if [ -d ~/.ethereum/keystore ]; then
    cp -r ~/.ethereum/keystore "$BACKUP_DIR/ethereum-keystore"
    echo "✅ Ethereum keystore backed up"
fi

# Backup configuration files
cp ~/.bitcoin/bitcoin.conf "$BACKUP_DIR/" 2>/dev/null || true
cp ~/defi-projects/hardhat.config.js "$BACKUP_DIR/" 2>/dev/null || true

# Create encrypted archive
tar -czf "$BACKUP_DIR/../blockchain-backup-$(date +%Y%m%d).tar.gz" -C "$BACKUP_DIR" .
gpg --symmetric --cipher-algo AES256 "$BACKUP_DIR/../blockchain-backup-$(date +%Y%m%d).tar.gz"

echo "🔐 Encrypted backup created: blockchain-backup-$(date +%Y%m%d).tar.gz.gpg"
echo "💡 Store this backup in multiple secure locations!"
EOF

chmod +x ~/blockchain-backup.sh

Tip 2: Performance Monitoring Dashboard

# Create blockchain monitoring script
cat > ~/blockchain-monitor.sh << 'EOF'
#!/bin/bash
clear
echo "⛓️  AlmaLinux Blockchain Monitor"
echo "================================"

echo -e "\n🔗 Bitcoin Node Status:"
if systemctl is-active --quiet bitcoind; then
    info=$(bitcoin-cli getblockchaininfo 2>/dev/null)
    if [ $? -eq 0 ]; then
        blocks=$(echo "$info" | jq -r '.blocks')
        connections=$(bitcoin-cli getnetworkinfo 2>/dev/null | jq -r '.connections')
        echo "✅ Status: Running | Blocks: $blocks | Peers: $connections"
    else
        echo "🔄 Status: Syncing..."
    fi
else
    echo "❌ Status: Not running"
fi

echo -e "\n⚡ Ethereum Node Status:"
if systemctl is-active --quiet geth; then
    if curl -s -X POST -H "Content-Type: application/json" --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' http://localhost:8545 &>/dev/null; then
        echo "✅ Status: Running | RPC: Active"
    else
        echo "🔄 Status: Starting..."
    fi
else
    echo "❌ Status: Not running"
fi

echo -e "\n💾 Disk Usage:"
echo "Bitcoin: $(du -sh ~/.bitcoin 2>/dev/null | cut -f1 || echo 'N/A')"
echo "Ethereum: $(du -sh ~/.ethereum 2>/dev/null | cut -f1 || echo 'N/A')"

echo -e "\n🖥️  System Resources:"
echo "CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)%"
echo "Memory: $(free -h | awk 'NR==2{printf "%.1f%% (%s/%s)\n", $3*100/$2, $3, $2}')"
echo "Load: $(uptime | awk -F'load average:' '{print $2}')"

echo -e "\nLast updated: $(date)"
EOF

chmod +x ~/blockchain-monitor.sh

Tip 3: Security Audit Checklist

# Create security audit script
cat > ~/blockchain-security-audit.sh << 'EOF'
#!/bin/bash
echo "🛡️  Blockchain Security Audit"
echo "============================"

echo -e "\n🔐 Wallet Security:"
echo -n "Bitcoin wallet encrypted: "
bitcoin-cli getwalletinfo 2>/dev/null | jq -r '.encrypted' || echo "N/A"

echo -n "SSH key authentication: "
[ -f ~/.ssh/id_rsa ] && echo "✅ Configured" || echo "❌ Not found"

echo -e "\n🌐 Network Security:"
echo "Open ports:"
sudo netstat -tuln | grep -E ":(8333|8332|30303|8545)" || echo "No blockchain ports open"

echo -e "\n🔥 Firewall Status:"
sudo firewall-cmd --state

echo -e "\n🔒 File Permissions:"
echo -n "Bitcoin config: " && ls -la ~/.bitcoin/bitcoin.conf 2>/dev/null | awk '{print $1}' || echo "N/A"
echo -n "SSH directory: " && ls -ld ~/.ssh 2>/dev/null | awk '{print $1}' || echo "N/A"

echo -e "\n💡 Security Recommendations:"
echo "• Use hardware wallets for large amounts"
echo "• Enable 2FA on all exchange accounts"
echo "• Keep private keys offline and encrypted"
echo "• Regularly update node software"
echo "• Use VPN for additional privacy"
EOF

chmod +x ~/blockchain-security-audit.sh

🏆 What You’ve Accomplished - Blockchain Mastery!

Congratulations! You’ve built a complete blockchain powerhouse on AlmaLinux! 🎉 Let’s celebrate your achievements:

🚀 Complete Blockchain Infrastructure:

• ✅ Bitcoin Core full node running and syncing
• ✅ Ethereum development environment with Geth client
• ✅ DeFi development framework with Hardhat and OpenZeppelin
• ✅ Smart contract development and deployment capabilities
• ✅ Cryptocurrency mining software configured
• ✅ Secure wallet management and backup systems
• ✅ Professional monitoring and maintenance tools
• ✅ Advanced security hardening and audit procedures

💪 Professional Skills Gained:

• ✅ Blockchain node operation and maintenance
• ✅ Smart contract development with Solidity
• ✅ DeFi application architecture and deployment
• ✅ Cryptocurrency mining optimization
• ✅ Blockchain security best practices
• ✅ Web3 development environment mastery
• ✅ Network troubleshooting and performance tuning
• ✅ Automated backup and disaster recovery

🎯 Real-World Applications Ready:

• ✅ Full Bitcoin and Ethereum network participation
• ✅ Custom token and DeFi protocol development
• ✅ Secure wallet operations and transaction management
• ✅ Mining operation setup and optimization
• ✅ Blockchain data analysis and monitoring
• ✅ Enterprise-grade security implementations

🎯 Why This Blockchain Setup Matters

Your AlmaLinux system is now a professional blockchain development and operations platform! 🌟

Real-World Impact:

• 💰 Financial Independence - Direct participation in decentralized finance
• 🚀 Career Opportunities - Blockchain development is one of the highest-paying tech fields
• 🛡️ Enhanced Security - Full control over your cryptocurrency operations
• 🌐 Network Contribution - Supporting decentralized networks globally
• 📈 Investment Opportunities - Understanding technology enables better investment decisions
• 🔬 Innovation Platform - Build the next generation of financial applications
• 👥 Community Impact - Contribute to the future of decentralized technology
• 🎓 Continuous Learning - Stay at the forefront of technological advancement

You’re not just running blockchain software - you’re participating in a financial revolution! Whether you’re building the next DeFi protocol, mining cryptocurrency, or simply learning this transformative technology, your AlmaLinux blockchain environment provides everything needed for success! 🌈

The future is decentralized, and you’re ready to build it! ⭐ Happy blockchain development! 🙌