Build a Cryptocurrency

const EC = require('elliptic').ec;
const ec = new EC('secp256k1');   // Same curve as Bitcoin

class Wallet {
  constructor() {
    this.keyPair   = ec.genKeyPair();          // random private key → public point
    this.publicKey = this.keyPair.getPublic('hex'); // 130 hex chars (uncompressed)
  }

  // Sign a transaction hash — returns DER-encoded signature
  sign(dataHash) {
    return this.keyPair.sign(dataHash, 'hex')
      .toDER('hex');
  }
}

// Demo: create two wallets
const alice = new Wallet();
const bob   = new Wallet();
console.log('Alice:', alice.publicKey.slice(0, 40) + '…');
console.log('Bob:  ', bob.publicKey.slice(0, 40) + '…');

const { createHash } = require('crypto');
const EC = require('elliptic').ec;
const ec = new EC('secp256k1');   // Same curve as the Wallet

class Transaction {
  constructor(from, to, amount) {
    this.from      = from;     // sender public key (null = mining reward)
    this.to        = to;       // recipient public key
    this.amount    = amount;
    this.timestamp = Date.now();
    this.signature = null;      // filled when sign() is called
  }

  // SHA-256 of the TX data — this is what we sign
  calculateHash() {
    return createHash('sha256')
      .update(this.from + this.to + this.amount + this.timestamp)
      .digest('hex');
  }

  // Only the sender's wallet can sign (enforced by key check)
  sign(wallet) {
    if (wallet.publicKey !== this.from)
      throw new Error('Cannot sign for another wallet!');
    this.signature = wallet.sign(this.calculateHash());
  }

  // Anyone can verify using the sender's public key
  isValid() {
    if (this.from === null) return true;  // coinbase TX — no sender
    if (!this.signature) return false;  // unsigned = invalid
    const key = ec.keyFromPublic(this.from, 'hex');
    return key.verify(this.calculateHash(), this.signature);
  }
}

const { createHash } = require('crypto');

class Block {
  constructor(index, transactions, previousHash) {
    this.index        = index;
    this.timestamp    = Date.now();
    this.transactions = transactions;
    this.previousHash = previousHash;     // ← the "link" to the previous block
    this.nonce        = 0;                // ← the miner will change this
    this.hash         = this.calculateHash();
  }

  calculateHash() {
    return createHash('sha256')
      .update(
        this.index +
        this.timestamp +
        JSON.stringify(this.transactions) +
        this.previousHash +
        this.nonce              // nonce changes → hash changes
      ).digest('hex');
  }

  // Proof of work: increment nonce until hash starts with zeros
  mineBlock(difficulty) {
    const target = '0'.repeat(difficulty);
    while (this.hash.substring(0, difficulty) !== target) {
      this.nonce++;
      this.hash = this.calculateHash();
    }
    console.log('Block mined:', this.hash);
  }
}

class Blockchain {
  constructor() {
    this.chain       = [this.createGenesis()];
    this.difficulty   = 2;       // hash must start with "00"
    this.pending      = [];      // mempool — TXs waiting to be mined
    this.miningReward = 50;      // coinbase reward per block
  }

  createGenesis() {
    return new Block(0, [], '0'); // index 0, no TXs, no previous hash
  }

  getLatest() {
    return this.chain[this.chain.length - 1];
  }

  // Validate & add to mempool — signature check here!
  addTransaction(tx) {
    if (!tx.from || !tx.to)
      throw new Error('TX must have from and to');
    if (!tx.isValid())
      throw new Error('Cannot add invalid TX');
    this.pending.push(tx);
  }

  // Build a block from pending TXs, mine it, append to chain
  minePending(minerAddress) {
    // 1. Create coinbase reward TX
    const reward = new Transaction(null, minerAddress, this.miningReward);
    this.pending.push(reward);

    // 2. Build block with all pending TXs
    const block = new Block(
      this.chain.length,          // next index
      this.pending,               // transactions
      this.getLatest().hash        // previous block's hash
    );

    // 3. Mine: find the nonce (proof of work)
    block.mineBlock(this.difficulty);

    // 4. Append to chain & clear mempool
    this.chain.push(block);
    this.pending = [];
  }

  // Walk the entire chain to compute an address's balance
  getBalance(address) {
    let balance = 0;
    for (const block of this.chain)
      for (const tx of block.transactions) {
        if (tx.from === address) balance -= tx.amount;
        if (tx.to   === address) balance += tx.amount;
      }
    return balance;
  }

  // Verify every block: recalc hash + check previousHash link
  isValid() {
    for (let i = 1; i < this.chain.length; i++) {
      const curr = this.chain[i];
      const prev = this.chain[i - 1];
      if (curr.hash !== curr.calculateHash()) return false;
      if (curr.previousHash !== prev.hash) return false;
    }
    return true;
  }
}