Wake Solidity Development and Testing Framework

Wake provides several standardized testing patterns for smart contract development. These patterns help developers focus on critical aspects of contract behavior such as balance tracking, state changes, and complex multi-token interactions.

Key testing patterns include:

• Account Balance Testing: Verifying changes in token or native currency balances.
• Multi Token Interaction: Testing scenarios involving multiple different tokens.
• State Change Tracking: Ensuring contract state variables update correctly after transactions.
• Test Flow Branching: Managing complex test logic and conditional execution paths.

The Wake LSP server provides several developer productivity features for Solidity development:

• Navigation: Go to definition, Go to type definition, Go to implementation (for unimplemented functions/modifiers), and Find references.
• Hierarchy & Structure: View Type hierarchy (for contracts and virtual functions) and Document symbols.
• Information: Hover (includes OpenZeppelin documentation links), Document links, and Code lens (showing number of references above declarations).
• Refactoring: Rename symbols.
• Diagnostics: Displays compiler errors and results from Wake vulnerability detectors.

Wake loads printers from multiple sources, and if multiple printers share the same name, they are prioritized according to the following hierarchy (from highest to lowest priority):

1. Project-specific printers: Located in the ./printers directory of your project.
2. Global printers: Located in $XDG_DATA_HOME/wake/global-printers.
3. Printer packages (plugins): Such as wake_printers. If multiple packages provide the same printer, they are loaded in alphabetical order of their module names (the first package in alphabetical order has the lowest priority).

To inspect which sources are providing which printers, run wake print list.

# See the list of available sources for each printer
wake print list

An Account is an Address bound to a specific Chain. If no chain is specified during construction, the global chain object is used.

Important Constraints:

• Address and Account instances cannot be compared.
• Account instances from different chains cannot be compared using < or >.
• Most API functions do not accept Account instances from different chains. To bypass this, use the .address property of the account.

from wake.testing import Account, Chain, chain

other_chain = Chain()

# Account bound to global chain
acc1 = Account(0)
assert acc1 == Account(0, chain)

# Account bound to different chain
acc2 = Account(0, other_chain)
assert acc1 != acc2

Fuzzing in Wake is implemented via the FuzzTest class. A fuzz test consists of multiple sequences, where each sequence is an independent test case (all connected chains are reset). Each sequence is composed of a series of flows (atomic test steps).

To run a fuzz test, call the .run() method on an instance of your FuzzTest subclass with the following arguments:

• sequences_count: The number of independent test sequences to execute.
• flows_count: The number of flows to execute within each sequence.

Inside the test class, you can access self.sequence_num and self.flow_num (both 0-indexed) to track the current progress.

class CounterTest(FuzzTest):
    ...

CounterTest().run(sequences_count=10, flows_count=100)

Wake loads configuration from multiple sources. If a setting is defined in multiple places, the source with the highest precedence wins. The order of precedence (from lowest to highest) is:

1. Default values (built into Wake)
2. Global configuration file
3. Project configuration file
4. Environment variables
5. Command-line arguments

When testing factory contracts, parameters must be encoded to match the specific struct required by the chosen StrategyType. In the provided example, the following mapping is used:

Ensure that your helper methods (e.g., _encode_basic_params) correctly encode these fields into bytes before passing them to the contract's deploy function.

For single chain testing, Wake provides a global chain variable which is an instance of the Chain class. You can use this object to access chain data (like blocks and accounts) or modify chain parameters (like gas price or automine settings). For cross-chain testing, you should create additional Chain instances instead of relying on the global one.

from wake.testing import chain

def test_chain():
    # Use the global chain object
    print(chain.chain_id)
    print(chain.accounts)