Expressions

One ${{ ... }} language everywhere: conditions (where / if / assert / retry_if / condition / recheck) and values (args, messages, urls, bodies) all render through the same engine. It is GitHub-Actions-shaped on the outside and minijinja-powered underneath, tuned for EVM work: strict U256 math, case-insensitive addresses, and strict-undefined behavior (a typo'd key is an error, never a silent false).

where: "${{ trigger.args.sender in lists.watched_traders and trigger.args.amount0 > wei('1', 18) }}"
message: "mirrored ${{ format_units(trigger.args.value, 6) }} USDC — ${{ steps.mirror.tx.hash }}"

Contexts

rflow validate knows which roots are legal where — a reorg.* reference in a normal step, or sim.* outside assert_sim:, is a validation error, not a runtime surprise.

Operators

Boolean logic uses words, not symbols:

Everything else is as expected: == != < <= > >=, arithmetic + - * / %, membership x in list, string concat ~, definedness tests (x is defined / x is not defined — and/or short-circuit, so guards work), and inline conditionals in Python style:

args: ["${{ steps.gate.output if steps.gate.output < trigger.args.amount0 else trigger.args.amount0 }}"]

(there is no C-style cond ? a : b ternary).

Functions

All functions are strict: bad inputs raise template errors that route to failure handling — nothing degrades to floats or silent zeros.

U256 math is strict

Token amounts never touch floats:

• uint256 values that fit in a native integer stay native — every operator works, and the math is checked (overflow raises, never wraps)
• larger values stay exact as U256 objects — comparisons (> < ==) work directly; arithmetic on them is a loud error telling you to use mul_div/wei (which compute wide)
• decimal strings from event payloads coerce transparently in comparisons against wei(...) results

where: "${{ trigger.args.value > wei('100000', 6) }}"          # exact
args: ["${{ mul_div(trigger.args.value, 9950, 10000) }}"]      # 0.5% haircut, no overflow
message: "${{ format_units(trigger.args.value, 6) }} USDC"     # human-readable out

Addresses are case-insensitive

Every string in the context that looks like an address (0x + 40 hex) is normalized, so equality and list membership behave regardless of casing:

where: "${{ trigger.args.to == relayers.payout.address }}"        # just works
where: "${{ trigger.args.sender in lists.watched_traders }}"      # any casing in the seed

For literals you write yourself, either casing works when compared against context values; use lower('0xAbC...') or checksum(...) if you need a canonical form in output.

Conditions are strictly boolean

A where / if / assert / retry_if must evaluate to a real boolean. A non-bool result, an unknown key, or any evaluation error is a typed error routed to failure handling — never a silent false. You find out about typos on the first event, not never.

rflow validate additionally checks expressions statically: unknown context roots and references to steps/contracts/lists that don't exist are caught before boot.

Values keep their types

When a field is exactly one expression (args: ["${{ trigger.args.value }}"]), the value keeps its type — numbers stay numbers, U256s stay exact. Mixed text ("amount: ${{ x }}") renders to a string. Output is single-pass and never re-parsed, so event data can't inject expressions.