Declaring Effects

The uses clause declares what effects a function or contract requires. This section covers all the syntax variations.

Basic Syntax

Add a uses clause after the return type (if any):

fn function_name() uses (effect: EffectType) {
    // function body
}

fn with_params(x: u256) -> u256 uses (effect: EffectType) {
    // function body with return type
    x
}

Single Effect

The simplest form declares a single effect:

pub struct Storage {
    pub data: u256,
}

fn read_data() -> u256 uses (storage: Storage) {
    storage.data
}

fn write_data(value: u256) uses (mut storage: Storage) {
    storage.data = value
}

Named Effects

Give an effect a local name for clearer code:

fn process() uses (store: Storage) {
    // Access via the name 'store'
    let value = store.data
}

fn update() uses (mut store: Storage) {
    store.data = 100
}

Named effects are especially useful when:

• The effect type name is long
• You want more descriptive names in your function body
• You have multiple effects of similar types

Multiple Effects

Declare multiple effects using parentheses:

fn complex_operation() uses (storage: Storage, logger: Logger, config: Config) {
    // Has access to all three effects
}

Combine with names and mutability:

fn transfer() uses (mut balances: Balances, config: Config, mut log: Logger) {
    // balances and log are mutable
    // config is read-only
}

Effects on Contracts

Contracts can declare effects in their definition:

contract Token uses (mut ctx: Context) {
    store: TokenStorage,
}

The contract’s effects are available within its recv blocks. Helper functions called from recv blocks receive effects explicitly:

pub struct TokenStorage {
    pub balances: Map<u256, u256>,
}

// Helper function with explicit effects
fn do_transfer(from: u256, to: u256, amount: u256) uses (mut store: TokenStorage) {
    let from_balance = store.balances.get(from)
    let to_balance = store.balances.get(to)

    store.balances.set(from, from_balance - amount)
    store.balances.set(to, to_balance + amount)
}

Effect Types

Effects can be any type or trait:

Struct Effects

pub struct AppConfig {
    pub max_value: u256,
    pub enabled: bool,
}

fn check_config() -> bool uses (config: AppConfig) {
    config.enabled
}

Generic Effects

pub struct Cache<T> {
    pub value: T,
}

fn get_cached<T>() -> T uses (cache: Cache<T>) {
    cache.value
}

Syntax Summary

Form	Example
Single effect	uses (name: Effect)
Mutable effect	uses (mut name: Effect)
Multiple effects	uses (a: A, b: B, c: C)
Mixed mutability	uses (mut a: A, b: B)
With return type	fn foo() -> T uses (e: E)
On contract	contract C uses (e: Effect) { }

Common Patterns

Read-Only Helper

fn get_balance(account: u256) -> u256 uses (balances: Balances) {
    balances.get(account)
}

Mutable Operation

fn set_balance(account: u256, amount: u256) uses (mut balances: Balances) {
    balances.set(account, amount)
}

Multiple Concerns

fn logged_transfer(from: u256, to: u256, amount: u256)
    uses (mut balances: Balances, mut log: TransferLog)
{
    balances.transfer(from, to, amount)
    log.record(from, to, amount)
}