Torque

Blockchain testing framework built on distributed systems principles

Torque brings production-grade distributed systems testing to blockchain development. Test your contracts with:

• 🚀 Parallel Execution: Run thousands of tests concurrently (tasks, threads, or processes)
• 🔒 Full Isolation: Each test in its own process - no interference, no flaky tests
• 🎯 Deterministic: Reproducible tests with seeded randomness - same seed, same result
• 🔌 Pluggable Mocks: Hot-swap blockchain components (UniSwap, Aave, Balancer)
• ⚡ Fast: 10-100x faster than sequential testing frameworks
• 🌐 Multi-chain: Ethereum today, more chains tomorrow

Built in Rust with patterns from MIT's distributed systems course (6.5840).

Why Torque?

Existing tools (Hardhat, Foundry) are slow and unreliable because they lack:

• True test isolation (tests can interfere with each other)
• Parallel execution at scale (limited concurrency)
• Deterministic reproducibility (flaky tests are common)

Torque solves this with:

• Process-level isolation (like distributed databases)
• Trait-based abstraction (swap forks, mocks, simulations)
• Simulation framework (deterministic, reproducible testing)

Quick Start

use Torque::prelude::*;

#[Torque::test]
async fn test_uniswap_swap() {
    let mut chain = Chain::fork_ethereum(BlockNumber::Latest);
    chain.mock_uniswap();  // Use mock instead of real protocol

    let result = chain.execute(|c| {
        c.swap(USDC, WETH, amount_in)
    }).await?;

    assert_eq!(result.balance(WETH), expected);
}

Run tests in parallel:

# Run all tests across 8 processes
Torque test --parallel=process --workers=8

# Run specific test suite
Torque test integration/ --parallel=thread

Architecture

Torque abstracts three key layers:

1. Execution Layer (How tests run)

• Tasks: Async concurrency (1000+ tests)
• Threads: OS-level parallelism (CPU cores)
• Processes: Full isolation (separate memory)

2. Backend Layer (What blockchain to test against)

• Forked: Real blockchain state
• Mocked: Lightweight component mocks
• Simulated: Deterministic in-memory chain

3. Storage Layer (How state is managed)

• In-memory: Fast, ephemeral
• Persistent: Survives crashes
• Snapshot: Fork state per test

┌─────────────────────────────────────┐
│     Test Suite (Your Code)          │
└──────────────┬──────────────────────┘
               │
    ┌──────────┴──────────┐
    │  Torque Framework   │
    │  - Isolation        │
    │  - Parallelism      │
    │  - Determinism      │
    └──────────┬──────────┘
               │
     ┌─────────┴─────────┐
     │                   │
┌────▼────┐       ┌─────▼─────┐
│ Backend │       │ Executor  │
│ - Fork  │       │ - Task    │
│ - Mock  │       │ - Thread  │
│ - Sim   │       │ - Process │
└─────────┘       └───────────┘

Roadmap

Q1 2025: Alpha

• ✅ Core framework
• ✅ Ethereum support
• ✅ Process isolation
• ⏳ Plugin system

Q2 2025: Beta

• Multi-chain support (Polygon, Arbitrum)
• Mock library (UniSwap, Aave, Curve)
• Performance benchmarks
• Documentation

Q3 2025: v1.0

• Production-ready
• Cross-chain testing
• Advanced fault injection
• Cloud test runners

Status

⚠️ Early Development - Not Production Ready

Torque is under active development. APIs will change. Use at your own risk.

Currently implements:

• Core architecture
• Process isolation
• Parallel execution (tasks, threads)
• Ethereum backend (in progress)
• Plugin system (planned)
• Multi-chain (planned)

Philosophy

Torque applies distributed systems principles to blockchain testing:

• Isolation: Like distributed databases, tests must not interfere
• Determinism: Like Raft testing, reproducibility is critical
• Abstraction: Like runtime-agnostic libraries, swap implementations freely

Built by engineers who've worked on:

• Medical device systems (IEC 62304)
• Defense embedded systems (Ada, real-time)
• Production Rust microservices (Kubernetes)

We know how to build reliable systems. Now we're building reliable testing tools.

Contributing

Torque is open source (MIT licensed). Contributions welcome!

Areas we need help:

• Additional blockchain backends (Solana, Cosmos, etc.)
• Mock library implementations (DeFi protocols)
• Performance optimization
• Documentation and examples

See CONTRIBUTING.md for details.

License

MIT License - see LICENSE for details

Acknowledgments

Architecture patterns inspired by:

• MIT 6.5840 (Distributed Systems)
• etcd (Raft consensus implementation)
• Foundry/Anvil (Ethereum testing)
• Tokio (Rust async runtime)

Built with ❤️ and Rust 🦀

## GitHub Topics/Tags

**Add these to maximize discoverability:**
- `blockchain`
- `testing`
- `ethereum`
- `distributed-systems`
- `rust`
- `parallel`
- `test-framework`
- `web3`
- `smart-contracts`
- `defi`
- `hardhat-alternative`
- `foundry`

## Social Media One-Liner (Twitter/LinkedIn)

**When you announce it:**

Introducing Torque: blockchain testing framework with process isolation and parallel execution. Same tests, 10-100x faster. Built on distributed systems principles from MIT 6.5840.

Early alpha, MIT licensed, looking for feedback.

🦀 Rust | ⚡ Fast | 🔒 Isolated | 🎯 Deterministic

github.com/[you]/Torque

## My Final Recommendation

**GitHub Description (50 chars):**

Blockchain testing framework with parallel execution, process isolation, and pluggable mocks

**Why this works:**
- ✅ Clear what it does (blockchain testing)
- ✅ Key differentiators (parallel, isolated, pluggable)
- ✅ Searchable keywords (blockchain, testing, parallel)
- ✅ Professional tone (not overpromising)

**Tagline for README:**

Blockchain testing framework built on distributed systems principles