Blockchain & Web3 Engineer Guide: Smart Contracts, DeFi, ZK Proofs, and AI+Blockchain

import hashlib
import json

def compute_block_hash(index, previous_hash, timestamp, data, nonce):
    block_content = json.dumps({
        "index": index,
        "previous_hash": previous_hash,
        "timestamp": timestamp,
        "data": data,
        "nonce": nonce
    }, sort_keys=True)
    return hashlib.sha256(block_content.encode()).hexdigest()

# SHA-256 properties: deterministic, one-way, avalanche effect
hash1 = hashlib.sha256(b"hello").hexdigest()
hash2 = hashlib.sha256(b"hellO").hexdigest()
# A single character difference produces a completely different hash
print(hash1[:16], "vs", hash2[:16])

def build_merkle_tree(leaves):
    if not leaves:
        return None
    layer = [hashlib.sha256(leaf.encode()).hexdigest() for leaf in leaves]
    while len(layer) > 1:
        if len(layer) % 2 != 0:
            layer.append(layer[-1])  # duplicate last if odd
        layer = [
            hashlib.sha256((layer[i] + layer[i+1]).encode()).hexdigest()
            for i in range(0, len(layer), 2)
        ]
    return layer[0]  # Merkle Root

txs = ["tx_alice_to_bob", "tx_carol_to_dave", "tx_eve_to_frank", "tx_grace_to_heidi"]
root = build_merkle_tree(txs)
print("Merkle Root:", root)

EVM Stack Operation Example (PUSH1, ADD, MUL):
PUSH1 0x03   → Stack: [3]
PUSH1 0x04   → Stack: [3, 4]
ADD          → Stack: [7]
PUSH1 0x02   → Stack: [7, 2]
MUL          → Stack: [14]

# EIP-1559 transaction cost calculation
base_fee = 15  # gwei (auto-adjusted based on network state)
priority_fee = 2  # gwei (tip)
max_fee = 20  # gwei (maximum allowed)

actual_fee = min(base_fee + priority_fee, max_fee)
gas_used = 21000  # simple ETH transfer
total_cost_gwei = actual_fee * gas_used
total_cost_eth = total_cost_gwei / 1e9
print(f"Transaction fee: {total_cost_eth:.6f} ETH")
# base_fee burned → ETH deflationary effect
burned = base_fee * gas_used / 1e9
print(f"Burned ETH: {burned:.6f} ETH")

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

contract SecureToken is ERC20, ReentrancyGuard, Ownable {
    uint256 public constant MAX_SUPPLY = 1_000_000 * 10**18;
    mapping(address => uint256) public lockTime;

    event TokensLocked(address indexed user, uint256 amount, uint256 unlockTime);
    event TokensUnlocked(address indexed user, uint256 amount);

    constructor() ERC20("SecureToken", "STKN") Ownable(msg.sender) {
        _mint(msg.sender, 100_000 * 10**18);
    }

    // Applies the Checks-Effects-Interactions pattern
    function lockAndRelease(uint256 amount, uint256 duration)
        external
        nonReentrant  // reentrancy defense
    {
        // 1. Checks: validate conditions
        require(amount > 0, "Amount must be positive");
        require(balanceOf(msg.sender) >= amount, "Insufficient balance");
        require(duration >= 1 days && duration <= 365 days, "Invalid duration");

        // 2. Effects: state changes (before external calls)
        lockTime[msg.sender] = block.timestamp + duration;
        _transfer(msg.sender, address(this), amount);

        // 3. Interactions: external calls (after state changes)
        emit TokensLocked(msg.sender, amount, lockTime[msg.sender]);
    }

    function unlock() external nonReentrant {
        // Checks
        require(block.timestamp >= lockTime[msg.sender], "Still locked");
        uint256 contractBalance = balanceOf(address(this));
        require(contractBalance > 0, "Nothing to unlock");

        // Effects
        lockTime[msg.sender] = 0;

        // Interactions
        _transfer(address(this), msg.sender, contractBalance);
        emit TokensUnlocked(msg.sender, contractBalance);
    }

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

// Vulnerable contract (never use this)
contract VulnerableBank {
    mapping(address => uint256) public balances;

    function withdraw() external {
        uint256 amount = balances[msg.sender];
        // External call before state change → reentrancy possible!
        (bool success,) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
        balances[msg.sender] = 0;  // too late
    }
}

// Attacker contract
contract Attacker {
    VulnerableBank public target;

    receive() external payable {
        if (address(target).balance >= 1 ether) {
            target.withdraw();  // recursive call to drain repeatedly
        }
    }
}

const { expect } = require('chai')
const { ethers } = require('hardhat')

describe('SecureToken', function () {
  let token, owner, alice, bob

  beforeEach(async function () {
    ;[owner, alice, bob] = await ethers.getSigners()
    const SecureToken = await ethers.getContractFactory('SecureToken')
    token = await SecureToken.deploy()
    await token.waitForDeployment()
  })

  it('should defend against reentrancy attacks', async function () {
    // Transfer tokens to alice
    await token.transfer(alice.address, ethers.parseEther('1000'))
    expect(await token.balanceOf(alice.address)).to.equal(ethers.parseEther('1000'))
  })

  it('should not allow unlock before lock period ends', async function () {
    await token.transfer(alice.address, ethers.parseEther('100'))
    await token.connect(alice).lockAndRelease(
      ethers.parseEther('100'),
      86400 // 1 day
    )
    await expect(token.connect(alice).unlock()).to.be.revertedWith('Still locked')
  })

  it('Foundry-style fuzz test simulation', async function () {
    const amounts = [1, 100, 1000].map((n) => ethers.parseEther(n.toString()))
    for (const amount of amounts) {
      await token.mint(alice.address, amount)
    }
    const total = amounts.reduce((a, b) => a + b, 0n)
    expect(await token.balanceOf(alice.address)).to.equal(total)
  })
})

// test/SecureToken.t.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "forge-std/Test.sol";
import "../src/SecureToken.sol";

contract SecureTokenTest is Test {
    SecureToken public token;
    address public alice = makeAddr("alice");

    function setUp() public {
        token = new SecureToken();
        token.transfer(alice, 1000 ether);
    }

    function testLockRequiresDuration() public {
        vm.startPrank(alice);
        vm.expectRevert("Invalid duration");
        token.lockAndRelease(100 ether, 12 hours);  // less than 1 day
        vm.stopPrank();
    }

    // Fuzz test: repeated verification with arbitrary amounts
    function testFuzz_LockAmount(uint256 amount) public {
        amount = bound(amount, 1 ether, 1000 ether);
        vm.startPrank(alice);
        token.lockAndRelease(amount, 1 days);
        assertEq(token.balanceOf(address(token)), amount);
        vm.stopPrank();
    }
}

import math

# Uniswap v3 price calculation (tick-based)
# tick = log(sqrt(price)) / log(sqrt(1.0001))

def tick_to_price(tick):
    return 1.0001 ** tick

def price_to_tick(price):
    return math.floor(math.log(price) / math.log(1.0001))

def calculate_liquidity_v3(amount0, amount1, price_current, price_lower, price_upper):
    """Calculate L (liquidity) for a concentrated liquidity position"""
    sqrt_p = math.sqrt(price_current)
    sqrt_pa = math.sqrt(price_lower)
    sqrt_pb = math.sqrt(price_upper)

    if price_current <= price_lower:
        # entirely token0
        L = amount0 * (sqrt_pa * sqrt_pb) / (sqrt_pb - sqrt_pa)
    elif price_current >= price_upper:
        # entirely token1
        L = amount1 / (sqrt_pb - sqrt_pa)
    else:
        # mixed
        L0 = amount0 * (sqrt_p * sqrt_pb) / (sqrt_pb - sqrt_p)
        L1 = amount1 / (sqrt_p - sqrt_pa)
        L = min(L0, L1)
    return L

# ETH/USDC pool example
# Current price: 3000 USDC/ETH, range: 2500 ~ 3500
L = calculate_liquidity_v3(
    amount0=1.0,       # 1 ETH
    amount1=3000.0,    # 3000 USDC
    price_current=3000,
    price_lower=2500,
    price_upper=3500
)
print(f"Liquidity L: {L:.4f}")

// Simple ZK proof example using snarkjs
// circuit: a * b = c (proving multiplication without revealing a and b)

const snarkjs = require('snarkjs')
const fs = require('fs')

async function generateAndVerifyProof() {
  // 1. Compute witness (private input)
  const input = {
    a: 3, // secret
    b: 11, // secret
    c: 33, // public: a * b = c
  }

  // 2. Generate proof (requires proving key)
  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
    input,
    'multiply.wasm',
    'multiply_final.zkey'
  )

  console.log('Public signals:', publicSignals) // [33]
  console.log('Proof size:', JSON.stringify(proof).length, 'bytes')

  // 3. Verify (only verification key needed)
  const vKey = JSON.parse(fs.readFileSync('verification_key.json'))
  const isValid = await snarkjs.groth16.verify(vKey, publicSignals, proof)
  console.log('Proof valid:', isValid) // true
  // Without the proof, a=3 and b=11 cannot be deduced
}

generateAndVerifyProof()

L2 transaction batch processing:
[tx1, tx2, ..., tx1000]
        ↓ prover
ZK Proof (hundreds of bytes)
        ↓ L1 verifier
Ethereum Mainnet (99%+ gas savings)

# Conceptual example of FHE (Fully Homomorphic Encryption)
# Performing computation on encrypted data

# Real implementations: Microsoft SEAL, OpenFHE
# Conceptual example:
def fhe_inference_concept(encrypted_input, model_weights):
    """
    With FHE, AI inference can be performed on encrypted input data
    without decryption:
    - Medical data: diagnosis without exposing patient information
    - Financial data: credit scoring with privacy preserved
    """
    # Homomorphic operations (addition and multiplication possible in encrypted state)
    encrypted_result = homomorphic_matrix_multiply(
        encrypted_input,
        model_weights  # model is public, only input is encrypted
    )
    return encrypted_result

from web3 import Web3
import json

# Alchemy/Infura RPC connection
w3 = Web3(Web3.HTTPProvider("https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"))
print("Connected:", w3.is_connected())
print("Latest block:", w3.eth.block_number)

# ERC-20 balance query
ERC20_ABI = [
    {"inputs": [{"name": "account", "type": "address"}],
     "name": "balanceOf",
     "outputs": [{"name": "", "type": "uint256"}],
     "type": "function"},
    {"inputs": [],
     "name": "symbol",
     "outputs": [{"name": "", "type": "string"}],
     "type": "function"}
]

USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
usdc = w3.eth.contract(
    address=Web3.to_checksum_address(USDC_ADDRESS),
    abi=ERC20_ABI
)

address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"  # vitalik.eth
balance = usdc.functions.balanceOf(address).call()
symbol = usdc.functions.symbol().call()
print(f"{symbol} balance: {balance / 10**6:.2f}")

# Send transaction (with signing)
def send_erc20(private_key, to_address, amount_wei):
    account = w3.eth.account.from_key(private_key)
    nonce = w3.eth.get_transaction_count(account.address)
    tx = usdc.functions.transfer(to_address, amount_wei).build_transaction({
        "from": account.address,
        "nonce": nonce,
        "gas": 100000,
        "maxFeePerGas": w3.to_wei(20, "gwei"),
        "maxPriorityFeePerGas": w3.to_wei(2, "gwei"),
    })
    signed = w3.eth.account.sign_transaction(tx, private_key)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    return tx_hash.hex()

import { ethers } from 'ethers'

// Provider setup
const provider = new ethers.JsonRpcProvider('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY')

// ENS name resolution
const address = await provider.resolveName('vitalik.eth')
console.log('vitalik.eth →', address)

// Event subscription (real-time Transfer detection)
const ERC20_FILTER_ABI = ['event Transfer(address indexed from, address indexed to, uint256 value)']
const usdc = new ethers.Contract(
  '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  ERC20_FILTER_ABI,
  provider
)

usdc.on('Transfer', (from, to, value, event) => {
  const amount = ethers.formatUnits(value, 6)
  if (parseFloat(amount) > 100000) {
    console.log(`Large USDC transfer: ${amount} USDC`)
    console.log(`from: ${from} → to: ${to}`)
    console.log(`tx: ${event.log.transactionHash}`)
  }
})