# Wake: A Python Framework for Secure Solidity Development and Fuzz Testing

This repository profile is provided by osrepos.com, an open source repository discovery platform.

Source: osrepos.com
Repository profile: https://osrepos.com/repo/ackee-blockchain-wake
Generated for open source discovery and AI-assisted research.

Wake is a robust Python-based framework designed for secure Solidity development and comprehensive fuzz testing. It provides built-in vulnerability detectors, helping developers build more secure Ethereum dApps. With features like a VS Code extension and CI/CD integration, Wake streamlines the smart contract development workflow.

GitHub: https://github.com/Ackee-Blockchain/wake
OSRepos URL: https://osrepos.com/repo/ackee-blockchain-wake

## Summary

Wake is a robust Python-based framework designed for secure Solidity development and comprehensive fuzz testing. It provides built-in vulnerability detectors, helping developers build more secure Ethereum dApps. With features like a VS Code extension and CI/CD integration, Wake streamlines the smart contract development workflow.

## Topics

- python
- solidity
- testing
- fuzzing
- static-analysis
- blockchain
- ethereum
- smart-contracts

## Repository Information

Last analyzed by OSRepos: Wed Jan 21 2026 08:01:27 GMT+0000 (Western European Standard Time)
Detail views: 9
GitHub clicks: 13

## Safety Notice

OSRepos shares public repositories for knowledge and discovery only. Review source code, dependencies, licenses, and security implications before running or installing anything.

## Content

## Introduction

Wake is a powerful Python-based framework for Solidity development and fuzz testing, created by Ackee Blockchain Security. Trusted auditors of major projects like Lido, Safe, and Axelar, Ackee Blockchain built Wake to help developers write safer smart contracts faster. It offers a comprehensive suite of tools for testing, analysis, and deployment of Ethereum dApps.

## Installation

To get started with Wake, ensure you have Python 3.8 or higher installed. For Apple Silicon Macs, Rosetta must be enabled.

Install Wake via `pip`:

bash
pip3 install eth-wake


## Examples

Wake offers powerful features for testing and development.

**Fuzzer Example**

Wake's fuzzer is built on its testing framework, enabling efficient fuzz testing of Solidity smart contracts. Here's an example of a fuzz test for a simple counter contract:

python
from wake.testing import *
from wake.testing.fuzzing import *
from pytypes.contracts.Counter import Counter

class CounterTest(FuzzTest):
    def pre_sequence(self) -> None:
        self.counter = Counter.deploy()
        self.count = 0

    @flow()
    def increment(self) -> None:
        self.counter.increment()
        self.count += 1

    @flow()
    def decrement(self) -> None:
        with may_revert(PanicCodeEnum.UNDERFLOW_OVERFLOW) as e:
            self.counter.decrement()

        if e.value is not None:
            assert self.count == 0
        else:
            self.count -= 1

    @invariant(period=10)
    def count(self) -> None:
        assert self.counter.count() == self.count

@chain.connect()
def test_counter():
    CounterTest().run(sequences_count=30, flows_count=100)


**Detectors and Printers**

Wake includes built-in vulnerability and code quality detectors. You can run all detectors with:

bash
wake detect all


To run a specific detector, use:

bash
wake detect <detector-name>


Printers can extract useful information from Solidity code:

bash
wake print <printer-name>


For custom detectors and printers, refer to the [getting started guide](https://ackee.xyz/wake/docs/latest/static-analysis/getting-started/ "Wake Static Analysis Getting Started Guide" target="_blank").

**LSP Server**

Wake implements a Language Server Protocol (LSP) server for Solidity, providing features like autocompletion and hints in your IDE. Run it with:

bash
wake lsp


You can also specify a port (default is 65432):

bash
wake lsp --port 1234


## Why Use Wake

Wake stands out as a comprehensive framework for Solidity development due to its unique combination of features:

*   **Built-in Fuzzing:** Automatically generates diverse inputs and edge cases to uncover hidden vulnerabilities, including manually-guided and property-based fuzzing.
*   **Vulnerability Detectors:** Catches common issues like reentrancy, overflows, and logic flaws early in the development cycle.
*   **Seamless Developer Experience:** Offers a VS Code extension, GitHub Actions for CI/CD integration, and a `solc` manager for consistent builds.
*   **Cross-chain Testing:** Compatible with popular environments such as Anvil, Hardhat, and Ganache.
*   **Pytest Integration:** Leverages the familiar `pytest` framework for writing clean and simple tests.
*   **Static Analysis Framework:** Provides a robust framework for custom detectors and printers, allowing for project-specific rules and insights.
*   **Language Server Protocol (LSP):** Delivers autocompletion, hints, and references directly within your IDE, enhancing productivity.

Wake's ability to combine advanced fuzzing, static analysis with detectors, and a full-featured LSP server in a Python environment makes it a powerful tool for ensuring the security and quality of smart contracts.

## Links

For more detailed information, contributions, and community engagement, explore the following resources:

*   [Wake Documentation](https://ackee.xyz/wake/docs/latest "Wake Documentation" target="_blank")
*   [Contributing Guide](https://ackee.xyz/wake/docs/latest/contributing/ "Wake Contributing Guide" target="_blank")
*   [Follow Wake on X/Twitter](https://x.com/WakeFramework "Wake Framework on X/Twitter" target="_blank")
*   [Wake GitHub Repository](https://github.com/Ackee-Blockchain/wake "Wake GitHub Repository" target="_blank")