Building a Crypto Wallet: Architecture and Security

const { ethers } = require("ethers");

// Generate a wallet from mnemonic
function createHDWallet(mnemonic, derivationPath = "m/44'/60'/0'/0/0") {
  // Validate mnemonic
  if (!mnemonic) {
    mnemonic = ethers.Mnemonic.fromEntropy(ethers.randomBytes(32));
  }
  
  // Create HD wallet
  const hdNode = ethers.HDNodeWallet.fromPhrase(
    mnemonic.phrase || mnemonic,
    undefined,
    derivationPath
  );
  
  return {
    mnemonic: hdNode.mnemonic.phrase,
    privateKey: hdNode.privateKey,
    address: hdNode.address,
    derivationPath: hdNode.path,
    publicKey: hdNode.publicKey,
    fingerprint: hdNode.fingerprint,
  };
}

// Generate first 5 Ethereum addresses from same seed
function deriveAddresses(mnemonic, count = 5) {
  const addresses = [];
  
  for (let i = 0; i < count; i++) {
    const path = `m/44'/60'/0'/0/${i}`;
    const wallet = ethers.HDNodeWallet.fromPhrase(mnemonic, undefined, path);
    addresses.push({
      index: i,
      address: wallet.address,
      path: path,
      privateKey: wallet.privateKey,
    });
  }
  
  return addresses;
}

// Create wallet
const wallet = createHDWallet();
console.log("Mnemonic:", wallet.mnemonic);
console.log("Address:", wallet.address);

// Derive multiple addresses
const addresses = deriveAddresses(wallet.mnemonic, 3);
addresses.forEach(addr => {
  console.log(`${addr.path}: ${addr.address}`);
});

// Expected output:
// Mnemonic: abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about
// Address: 0x...
// m/44'/60'/0'/0/0: 0x...
// m/44'/60'/0'/0/1: 0x...
// m/44'/60'/0'/0/2: 0x...

const { ethers } = require("ethers");
const fs = require("fs");

// Encrypt a private key with a password (JSON keystore)
async function encryptKeystore(privateKey, password) {
  const wallet = new ethers.Wallet(privateKey);
  
  const encryptedJson = await wallet.encrypt(password, {
    scrypt: {
      N: 131072,  // 2^17 - higher = more secure but slower
      r: 8,
      p: 1,
    },
  });
  
  // Save to file
  fs.writeFileSync("wallet.json", encryptedJson);
  console.log("Wallet encrypted and saved to wallet.json");
  
  return encryptedJson;
}

// Decrypt keystore
async function decryptKeystore(password) {
  const encryptedJson = fs.readFileSync("wallet.json", "utf8");
  const wallet = await ethers.Wallet.fromEncryptedJson(encryptedJson, password);
  
  return {
    address: wallet.address,
    privateKey: wallet.privateKey,
    provider: wallet.provider,
  };
}

// Usage
encryptKeystore("0x...privatekey...", "strong_password123").then(() => {
  console.log("Encryption complete");
});

// Expected output:
// Wallet encrypted and saved to wallet.json
// Encryption complete

const { ethers } = require("ethers");

class WalletSigner {
  constructor(privateKey, provider) {
    this.wallet = new ethers.Wallet(privateKey, provider);
  }
  
  async signAndSendTransaction(to, valueInEth, data = "0x") {
    // Build transaction
    const tx = {
      to: to,
      value: ethers.parseEther(valueInEth),
      data: data,
    };
    
    // Estimate gas (optional but recommended)
    let gasEstimate;
    try {
      gasEstimate = await this.wallet.estimateGas(tx);
      console.log("Estimated gas:", gasEstimate.toString());
    } catch (error) {
      console.log("Gas estimation failed, using default");
      gasEstimate = 21000n;
    }
    
    // Get fee data
    const feeData = await this.wallet.provider.getFeeData();
    
    // Sign the transaction locally
    const signedTx = await this.wallet.signTransaction({
      ...tx,
      gasLimit: gasEstimate,
      maxFeePerGas: feeData.maxFeePerGas,
      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
      nonce: await this.wallet.getNonce(),
      chainId: (await this.wallet.provider.getNetwork()).chainId,
    });
    
    console.log("Transaction signed locally");
    console.log("Signed hex:", signedTx.slice(0, 20) + "...");
    
    // Broadcast
    const response = await this.wallet.provider.broadcastTransaction(signedTx);
    console.log("Transaction sent:", response.hash);
    
    // Wait for confirmation
    const receipt = await response.wait();
    console.log("Confirmed in block:", receipt.blockNumber);
    console.log("Status:", receipt.status === 1 ? "Success" : "Failed");
    
    return receipt;
  }
  
  async signMessage(message) {
    const signature = await this.wallet.signMessage(message);
    console.log("Message signed");
    
    // Verify signature
    const recovered = ethers.verifyMessage(message, signature);
    const isValid = recovered.toLowerCase() === this.wallet.address.toLowerCase();
    console.log("Signature valid:", isValid);
    
    return signature;
  }
}

// Usage
const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
const signer = new WalletSigner("0x...privatekey...", provider);

signer.signAndSendTransaction("0x...", "0.1").then(receipt => {
  console.log("Transaction complete:", receipt.hash);
});

// Expected output:
// Estimated gas: 21000
// Transaction signed locally
// Transaction sent: 0x7a3f...
// Confirmed in block: 5
// Status: Success

const { ethers } = require("ethers");
const { LedgerSigner } = require("@ethers-ext/signer-ledger");

async function connectLedger() {
  // Connect to Ledger via USB
  const signer = new LedgerSigner(undefined, "live", "hid");
  
  console.log("Connected to Ledger");
  
  // Get first address
  const address = await signer.getAddress();
  console.log("Ledger address:", address);
  
  // Get multiple addresses
  const paths = [
    "m/44'/60'/0'/0/0",
    "m/44'/60'/0'/0/1",
    "m/44'/60'/0'/0/2",
  ];
  
  for (const path of paths) {
    const addr = await signer.getAddress(path);
    console.log(`${path}: ${addr}`);
  }
  
  // Sign transaction (requires physical approval on Ledger)
  const tx = await signer.sendTransaction({
    to: "0x...",
    value: ethers.parseEther("0.01"),
  });
  
  console.log("Transaction sent. Check Ledger for approval.");
  console.log("Hash:", tx.hash);
}

// Expected output:
// Connected to Ledger
// Ledger address: 0x...
// m/44'/60'/0'/0/0: 0x...
// m/44'/60'/0'/0/1: 0x...
// Transaction sent. Check Ledger for approval.
// Hash: 0x...

import { useState, useEffect } from "react";
import { ethers } from "ethers";

function WalletApp() {
  const [wallet, setWallet] = useState(null);
  const [balance, setBalance] = useState("0");
  const [address, setAddress] = useState("");
  const [network, setNetwork] = useState("");
  const [txHash, setTxHash] = useState("");
  
  async function createWalletFromMnemonic(mnemonic) {
    const hdNode = ethers.HDNodeWallet.fromPhrase(mnemonic);
    const provider = new ethers.JsonRpcProvider("http://127.0.0.1:8545");
    const connectedWallet = hdNode.connect(provider);
    
    setWallet(connectedWallet);
    setAddress(connectedWallet.address);
    
    const network = await provider.getNetwork();
    setNetwork(network.name);
    
    const bal = await provider.getBalance(connectedWallet.address);
    setBalance(ethers.formatEther(bal));
  }
  
  async function sendETH(to, amount) {
    if (!wallet) return;
    
    try {
      const tx = await wallet.sendTransaction({
        to: to,
        value: ethers.parseEther(amount),
      });
      
      setTxHash(tx.hash);
      
      const receipt = await tx.wait();
      console.log("Confirmed:", receipt.blockNumber);
      
      // Update balance
      const bal = await wallet.provider.getBalance(wallet.address);
      setBalance(ethers.formatEther(bal));
    } catch (error) {
      console.error("Transaction failed:", error.message);
    }
  }
  
  return (
    <div>
      <h1>Simple Wallet</h1>
      
      {!wallet ? (
        <div>
          <p>Enter mnemonic phrase to restore wallet, or generate a new one.</p>
          <button onClick={() => createWalletFromMnemonic("")}>
            Generate New Wallet
          </button>
        </div>
      ) : (
        <div>
          <p>Address: {address}</p>
          <p>Balance: {balance} ETH</p>
          <p>Network: {network}</p>
          
          <h2>Send ETH</h2>
          <input type="text" placeholder="Recipient address" id="to" />
          <input type="text" placeholder="Amount in ETH" id="amount" />
          <button onClick={() => {
            const to = document.getElementById("to").value;
            const amount = document.getElementById("amount").value;
            sendETH(to, amount);
          }}>
            Send
          </button>
          
          {txHash && <p>Transaction: {txHash}</p>}
        </div>
      )}
    </div>
  );
}