Permissionless Operations

Olla is designed so that anyone can keep the protocol running. Three core operations (rebalancing, accounting, and attester state refresh) are callable by any Ethereum address. There is no privileged operator role required.

This means the protocol doesn't depend on a single party being online. If the Olla team's infrastructure goes down, any user or community member can step in and call these functions to keep things moving.

What needs to happen and why

The protocol doesn't update itself automatically. Someone needs to trigger each step by sending a transaction. Here's what each operation does:

Rebalance

What it does: Moves assets between the vault buffer and the Aztec rollup.

Think of the buffer as a checking account and the rollup as a savings account. Deposits land in the checking account. Rebalance moves surplus to savings (staking), or pulls from savings when users want to withdraw.

A rebalance cycle runs five steps:

1. Collect any earned rewards from the rollup.
2. Pull back any funds that finished unstaking.
3. Pay out queued withdrawal requests.
4. Start unstaking more if needed to cover pending withdrawals.
5. Stake any surplus buffer into the rollup.

How often: Rate-limited by a cooldown (configurable between 10 minutes and 24 hours). You can only start a new cycle after the cooldown elapses. If a cycle is already in progress, anyone can continue it without waiting.

How to call it:

cast send <OllaCore> "rebalance()" --private-key <your_key> --rpc-url <rpc>

Update Accounting

What it does: Recalculates the exchange rate between Aztec and stAztec.

After a rebalance, the protocol needs to account for any rewards earned and any slashing that occurred. This updates the exchange rate, mints protocol fee shares, and runs safety checks (circuit breakers).

When to call it: After a rebalance cycle completes (step = Done). Can also be called independently to refresh the rate.

How to call it:

cast send <OllaCore> "updateAccounting()" --private-key <your_key> --rpc-url <rpc>

Refresh Attester State

What it does: Syncs the protocol's view of each attester (validator) with the Aztec rollup's actual state.

Attesters can be slashed, exit voluntarily, or get stuck in queues. This function reads the current state from the rollup and updates the protocol's records: detecting slashing, finalizing completed exits, and promoting queued attesters to active.

When to call it: Before a rebalance, or whenever you suspect attester states are stale (e.g., after a slashing event on the rollup). Takes an array of attester addresses.

How to call it:

cast send <StakingManager> "refreshAttesterState(address[])" "[0xAttester1,0xAttester2]" --private-key <your_key> --rpc-url <rpc>

Purge Failed Queue Entry

What it does: Cleans up an attester that was queued for staking but failed to activate on the rollup (e.g., due to an invalid BLS proof or duplicate key).

This is a rare edge case. If it happens, the attester gets stuck as "Queued" in the protocol with inflated staked amounts. This function detects that the attester is no longer in the rollup's entry queue and corrects the accounting.

How to call it:

cast send <StakingManager> "purgeFailedQueueEntry(address)" <attester_address> --private-key <your_key> --rpc-url <rpc>

The Butler

Olla runs an automated service called the Butler that handles these operations continuously. It monitors protocol state and executes transactions when conditions are met:

Operation	Check interval	Trigger condition
Update accounting	Every 5 min	Last report older than staleness threshold
Rebalance	Every 15 min	On-chain cooldown elapsed
Refresh attester state	Every 60s	Stale or unhealthy attesters detected
Flush entry queue	Every 60s	Queued attesters ready + rollup epoch allows it

The Butler also exposes Prometheus metrics and alerting for monitoring protocol health (exchange rate, buffer levels, attester status, circuit breaker events).

Running the Butler yourself

The Butler is open source at ollafinance/olla-butler. Anyone can run their own instance:

# Install
git clone https://github.com/ollafinance/olla-butler
cd olla-butler
npm install

# Configure
mkdir -p ~/.config/olla-butler
cat > ~/.config/olla-butler/mainnet-base.env << 'EOF'
ETHEREUM_CHAIN_ID=1
ETHEREUM_NODE_URL=https://your-rpc-endpoint.com
OLLA_CORE_ADDRESS=0x...
TX_EXECUTOR_ENABLED=true
BUTLER_PRIVATE_KEY=0x...
EOF

# Run
npm run start:serve -- mainnet

In monitoring-only mode (omit TX_EXECUTOR_ENABLED and BUTLER_PRIVATE_KEY), the Butler just scrapes state and exposes metrics without sending any transactions. This is useful if you want to monitor the protocol without paying gas.

Why you should participate

Even though the Butler handles operations automatically, there are good reasons for community members to run their own callers:

• Redundancy: If Olla's Butler goes offline, the protocol keeps running as long as someone calls these functions.
• Decentralization: The more independent callers, the less the protocol depends on any single party.
• Transparency: Running your own monitoring lets you verify the protocol's health independently.

You don't need special permissions, roles, or approval. Just an Ethereum wallet with enough ETH for gas.