Build a Basic Crypto Wallet in Solidity

// Manual RPC communication with fallback endpoints for maximum reliability
// This array provides backup options if primary RPC endpoint fails
const rpcUrls = [
  'https://ethereum-sepolia-rpc.publicnode.com',  // Free public RPC
  'https://sepolia.gateway.tenderly.co',          // Tenderly's gateway
  'https://rpc.sepolia.org'                       // Community RPC
];

// Manual balance fetching function - bypasses all wallet libraries
async function getBalanceManually(address, rpcUrl) {
  // Make HTTP POST request to RPC endpoint
  // This is exactly what MetaMask does behind the scenes
  const response = await fetch(rpcUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',              // JSON-RPC protocol version
      method: 'eth_getBalance',    // Ethereum method to get balance
      params: [address, 'latest'], // Address and block number
      id: 1                        // Request ID for tracking
    })
  });
  
  // Parse JSON response from the blockchain node
  const data = await response.json();
  
  // Convert balance from wei (smallest unit) to ETH for display
  // 1 ETH = 10^18 wei
  return formatEther(data.result);
}

// Retry logic with timeout handling - ensures reliability
// Try each RPC endpoint until one succeeds
for (const rpcUrl of rpcUrls) {
  try {
    // Create timeout promise - don't wait forever for slow endpoints
    const timeoutPromise = new Promise((_, reject) => {
      setTimeout(() => reject(new Error('Timeout')), 5000);
    });
    
    // Make the balance request to current RPC endpoint
    const balancePromise = getBalanceManually(address, rpcUrl);
    
    // Race the request against timeout - whichever finishes first wins
    balance = await Promise.race([balancePromise, timeoutPromise]);
    
    // Success! Exit the retry loop
    break;
  } catch (error) {
    // This endpoint failed, try the next one in the array
    continue;
  }
}

// Manual address validation without libraries - critical security function
function isValidAddress(address) {
  // Ethereum addresses must be exactly 42 characters:
  // "0x" prefix + 40 hexadecimal characters (0-9, a-f, A-F)
  // This prevents sending funds to invalid/malformed addresses
  const addressRegex = /^0x[a-fA-F0-9]{40}$/;
  return addressRegex.test(address);
}

// Manual transaction validation - check everything before sending
// This prevents expensive failed transactions on the blockchain
async function validateTransaction(fromAddress, toAddress, amount, privateKey) {
  
  // 1. Recipient address validation
  // Invalid addresses would cause permanent loss of funds
  if (!isValidAddress(toAddress)) {
    throw new Error('Invalid recipient address');
  }
  
  // 2. Sender address validation
  // Ensures the "from" address is properly formatted
  if (!isValidAddress(fromAddress)) {
    throw new Error('Invalid sender address');
  }
  
  // 3. Private key validation
  // Without private key, we can't sign the transaction
  if (!privateKey) {
    throw new Error('Private key required for transaction signing');
  }
  
  // 4. Balance validation - prevent insufficient funds errors
  // Check if sender has enough ETH to cover amount + gas fees
  const balance = await getBalanceManually(fromAddress);
  
  // Manual gas estimation (in production, fetch from network)
  // Gas price = 21000 gwei * current gas price per gwei
  const gasPrice = 0.000021;
  
  // Calculate total cost: amount to send + network fees
  const totalCost = parseFloat(amount) + gasPrice;
  
  // Ensure user has enough funds for transaction + fees
  if (totalCost > parseFloat(balance)) {
    throw new Error('Insufficient balance for transaction');
  }
  
  // All validations passed - safe to proceed with transaction
  return true;
}

// Manual raw transaction creation - the heart of the wallet
// This function replaces what ethers.js or web3.js would do automatically
async function sendRawTransaction(privateKey, fromAddress, toAddress, amount) {
  
  // 1. Get current nonce manually from the blockchain
  // Nonce prevents replay attacks and ensures transaction ordering
  const nonce = await getNonceManually(fromAddress);
  
  // 2. Build transaction object manually - every field is critical
  const transaction = {
    nonce: nonce,                         // Transaction counter for this account
    gasPrice: '20000000000',              // 20 Gwei in wei (gas price)
    gasLimit: 21000,                      // Gas limit for ETH transfer
    to: toAddress,                        // Recipient address
    value: parseEther(amount),            // Convert ETH to wei (1 ETH = 10^18 wei)
    data: '0x',                           // Empty data for simple ETH transfer
    chainId: 11155111                     // Sepolia testnet identifier
  };
  
  // 3. Sign transaction manually with private key
  // This creates cryptographic proof that you own the sending address
  const signedTx = await signTransactionManually(transaction, privateKey);
  
  // 4. Broadcast to network manually - send to all connected peers
  // This is where the transaction enters the blockchain mempool
  const txHash = await broadcastTransactionManually(signedTx);
  
  // Return transaction hash for user to track on block explorer
  return { transactionHash: txHash };
}

// Manual transaction broadcasting - submit to blockchain network
async function broadcastTransactionManually(signedTx) {
  // Send signed transaction to RPC endpoint
  // This submits the transaction to the network for mining
  const response = await fetch(rpcUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',                     // JSON-RPC protocol version
      method: 'eth_sendRawTransaction',   // Ethereum method to send transaction
      params: [signedTx],                 // Signed transaction data
      id: 1                               // Request ID
    })
  });
  
  // Parse response from blockchain node
  const data = await response.json();
  
  // Check for errors (invalid transaction, insufficient gas, etc.)
  if (data.error) throw new Error(data.error.message);
  
  // Return transaction hash for tracking
  return data.result;
}

// Manual transaction submission and result handling
export const action = async ({ request }) => {
  const formData = await request.formData();
  const amount = formData.get('amount')?.toString() || '0';
  const toAddress = formData.get('toAddress')?.toString() || '';
  const fromAddress = formData.get('fromAddress')?.toString() || '';
  const privateKey = formData.get('privateKey')?.toString() || '';

  try {
    // Manual transaction validation before sending
    await validateTransaction(fromAddress, toAddress, amount, privateKey);
    
    // Manual raw transaction creation and sending
    const tx = await sendRawTransaction(privateKey, fromAddress, toAddress, amount);
    
    return json({ 
      success: true, 
      txHash: tx.transactionHash 
    });
  } catch (error) {
    return json({ 
      success: false, 
      error: error.message 
    });
  }
};

// Manual transaction status display
{actionData && (
  <div className={`transaction-result ${actionData.success ? 'success' : 'error'}`}>
    {actionData.success ? (
      <div>
        <h3>Transaction Sent!</h3>
        <p>Transaction Hash: {actionData.txHash}</p>
        <a href={`https://sepolia.etherscan.io/tx/${actionData.txHash}`}>
          View on Etherscan
        </a>
      </div>
    ) : (
      <div>
        <h3>Transaction Failed</h3>
        <p>Error: {actionData.error}</p>
      </div>
    )}
  </div>
)}