Execution Layer for On-Chain Automation
Permissionless execution network with on-chain condition verification. No trusted keepers. No off-chain dependencies. No Chainlink. No Gelato.
Optimistic execution layer for autonomous protocols on Base.
Optimistic execution · Executor staking · MEV-resistant ordering · Real network
RPC: mainnet.base.org · Real block data · No custom chain · No protocol token
Target Users
Who Uses Heliora
Heliora is built for protocols that require reliable, verifiable on-chain automation.
DeFi Protocols
Liquidations, rebalancing, auctions, and other time-sensitive operations that require on-chain condition verification.
DAOs
Governance execution, treasury automation, and scheduled protocol upgrades without trusted intermediaries.
Asset Managers
Periodic actions, risk threshold monitoring, and automated portfolio rebalancing with on-chain verification.
Infrastructure Protocols
Replacing trusted keepers with permissionless execution. Building autonomous systems that execute by conditions.
Pilot Use Case
Automated Liquidation Execution
Demonstrating Heliora's execution flow with a real-world DeFi automation scenario.
✓ Production execution network with verified on-chain transactions and cryptoeconomic security.
Competitive Advantage
Why Heliora is Better
Heliora provides a superior execution layer compared to existing keeper networks and automation solutions. We're cheaper, safer, and completely independent.
Cheaper than Keepers
No per-keeper subscription fees. Pay only for executions that happen. Value-based pricing for liquidations (0.1% of volume).
Keeper networks charge $50–200/month per keeper + execution fees
$500/month subscription + $0.01–$0.10 per execution
Safer — Cryptoeconomic Guarantees
Executor staking with slashing for invalid execution. Economic incentives ensure correctness, not just trust.
Keeper networks rely on reputation and manual slashing
Automatic slashing via on-chain verification + fraud proofs
No Off-Chain Dependencies
All condition verification happens on-chain. No need for off-chain oracles or committees.
Chainlink Automation requires DON (Decentralized Oracle Network) consensus
Single executor with on-chain condition verification
Independent Infrastructure
Works directly on Base Mainnet. No dependency on Chainlink, Gelato, or other third-party infrastructure.
Gelato requires their keeper network. Chainlink requires DON.
Permissionless executor set. No third-party infrastructure.
Real Network Execution
Executes on Base Mainnet with real block data. No custom chain. No protocol token.
Some solutions require custom chains or protocol tokens
Native Base execution. Real blocks. Real gas costs.
The Core Differentiator
Heliora is the first execution layer where execution conditions are verified entirely on-chain.
This means:
- No trusted keepers — anyone can be an executor with stake
- No committees — single executor with fraud-proof security
- No off-chain dependencies — all verification on-chain
- No third-party infrastructure — works directly on Base
- Cryptoeconomic security — stake is slashed for invalid execution
Feature Comparison
Comprehensive comparison of execution layer solutions
| Feature | Chainlink Automation | Gelato Network | Heliora |
|---|---|---|---|
| Off-chain Executors | Yes (DON network) | Yes (keeper network) | No (on-chain verification) |
| Trust Model | N-of-M committee consensus | Trusted keeper set | Trustless (staking + slashing) |
| On-chain Condition Verification | Partial (via DON) | Partial | Full (entirely on-chain) |
| MEV Protection | Limited | Partial | Yes (commit-reveal) |
| Economic Guarantees | Reputation-based | Reputation-based | Staking + slashing |
| Censorship Risk | Medium (DON operators) | Medium (keeper set) | Low (permissionless) |
| Single Point of Failure | Yes (DON dependency) | Yes (keeper network) | No (independent) |
| Integration Complexity | Medium (DON setup required) | Medium (keeper registration) | Low (~100-200 lines Solidity) |
| Third-party Dependencies | Yes (Chainlink DON) | Yes (Gelato infrastructure) | No (direct Base execution) |
| Cost (100 executions/mo) | ~$1,500/mo | ~$2,000/mo | ~$510/mo |
Total Cost of Ownership (TCO) Analysis
For a DeFi protocol running 100 liquidations per month
Why Heliora is cheaper:
- No off-chain infrastructure overhead (DON/keeper networks)
- On-chain verification eliminates committee consensus costs
- Simpler integration reduces development time
- No dependency on external operator networks
Protocol Capabilities
Infrastructure for Autonomous Protocols
Execution primitives for protocols that need reliable, verifiable automation
Conditional Execution
Register conditions as on-chain state predicates. Heliora evaluates against storage slots, oracle feeds, or block parameters. Conditions are immutable once registered.
Supports: storage proofs, Chainlink/Pyth oracles, block.number, block.timestamp
Execution Finality
Optimistic finality with 10-block challenge window. Immediate finality available with validity proofs (ZK mode). Executors post bonds proportional to execution value.
Finality: 10 blocks optimistic, instant with ZK proof
Gas Efficiency
Batch multiple executions into single transaction. Calldata compression for L2s. Executors compete on gas price, not just speed — protocols pay market rate.
Avg savings: 40% via batching on L1, 70% on L2
Base-Native
Core execution primitives deployed on Base. No custom chain, no protocol token. Leverages Base's security and low fees as the primary execution layer.
Primary: Base · Adapters: Ethereum, Arbitrum, Optimism
SDK & Tooling
TypeScript and Solidity SDKs for condition registration and monitoring. Simulation mode for testing execution logic before mainnet deployment.
npm: @heliora/sdk · forge: heliora-contracts
Execution Dashboard
Monitor condition status, execution history, and executor performance. Webhook notifications for execution events. Exportable logs for auditing.
API: REST + WebSocket · Export: JSON, CSV
Trust Model
Cryptoeconomic Execution Guarantees
Existing automation solutions rely on trusted operators, committee consensus, or third-party infrastructure (Chainlink DON, Gelato keepers). Heliora uses optimistic execution with fraud proofs — the same security model that secures optimistic rollups. Execution conditions verified entirely on-chain. No off-chain dependencies. No Chainlink. No Gelato.
Why Heliora: Heliora is the first execution layer where execution conditions are verified entirely on-chain. No trusted keepers. No committees. No off-chain dependencies. No Chainlink DON. No Gelato infrastructure. Security model based on optimistic execution with fraud proofs and cryptoeconomic guarantees.
Execution Correctness
Invalid executions are detected and penalized. Verifier contracts check Merkle proofs of condition state.
Liveness
Economic incentives ensure execution. Unfulfilled conditions with sufficient fee attract competing executors.
MEV Resistance
Commit-reveal prevents front-running of execution. Executors commit to condition ID before revealing execution details.
Roadmap
Development Roadmap
From production launch to ecosystem growth. Building the future of on-chain automation.
Production Launch
Base Mainnet execution network live. Core contracts deployed and verified.
- •HelioraExecutor contract on Base Mainnet
- •Real on-chain execution verified
- •Dashboard and API operational
- •Documentation and integration guides
Protocol Partnerships
Onboard first DeFi protocols. Build integration examples and case studies.
- •Pilot integrations with 3-5 DeFi protocols
- •Liquidation automation use cases
- •Integration SDK and examples
- •Community feedback and improvements
Scale & Enhance
Enhanced security model. Staking and slashing mechanisms. Multi-chain expansion.
- •Enhanced staking & slashing mechanisms
- •Advanced challenge & fraud proof system
- •Multi-chain support (Optimism, Arbitrum)
- •Performance optimizations
Ecosystem Growth
Enterprise features. ZK proofs for instant finality. Audit and security reviews.
- •ZK validity proofs for instant finality
- •Enterprise tier features
- •Security audits and certifications
- •Ecosystem partnerships and integrations
Protocol Architecture
How Execution Works
Heliora separates condition definition from execution. Protocols specify what should happen; the executor network handles when and how.
Condition Registry
On-chain registry on Base where protocols define execution conditions. Conditions are immutable once registered and reference specific contract states, oracle feeds, or block parameters.
- →Condition hash stored on Base
- →References to state slots / oracle addresses
- →Expiry and execution window parameters
Executor Network
Permissionless set of executors who stake collateral and compete to fulfill conditions. Any address with minimum stake can become an executor. No whitelisting.
- →Minimum stake: 1 ETH (configurable per condition)
- →Executor selection via commit-reveal auction
- →Stake slashable for invalid or delayed execution
Verification Layer
Execution validity is proven on-chain. Verifier contracts check that the condition was true at the claimed block before finalizing execution.
- →Merkle proof of condition state
- →Block header verification
- →Challenge period: 10 blocks (optimistic)
Settlement
After verification, execution is finalized. Executor receives fee from protocol. If challenged and found invalid, stake is slashed and challenger rewarded.
- →Fee paid in ETH or ERC-20
- →Slash: 100% of execution stake
- →Challenger reward: 50% of slashed stake
// 1. Protocol registers condition on Base
registry.register({
condition: "oracle.price(ETH/USD) > 3000",
callback: liquidator.execute(vaultId),
stake_required: 1 ether,
max_gas: 500_000,
expiry: block.number + 7200 // ~24h
});
// 2. Executor commits to execute
executor.commit(conditionId, commitment_hash);
// 3. Condition becomes true at block N
// 4. Executor reveals and executes
executor.reveal(conditionId, nonce); // within reveal_window
executor.execute(conditionId, proof); // merkle proof of condition
// 5. Verification (optimistic)
// - If no challenge in 10 blocks: finalized
// - If challenged: verifier checks proof on-chain
// - Invalid execution: executor slashed, challenger rewarded
// Cross-chain execution (via adapter)
adapter.executeOnChain(chainId, conditionId, proof);Developer Experience
Built for Protocol Developers
Everything you need to automate on-chain logic
Execution Layer
Infrastructure that handles all execution complexity. Focus on your protocol logic, not execution mechanics.
// Define execution condition
const condition = {
type: "price_threshold",
asset: "ETH/USD",
threshold: 3000,
direction: "above"
};
// Register with Heliora
heliora.register(condition, callback);Condition Monitoring
Monitor on-chain state and trigger executions when conditions match. Real-time event processing.
// Monitor multiple conditions
heliora.monitor([
{ contract: "0x...", event: "Transfer" },
{ oracle: "chainlink", pair: "ETH/USD" },
{ block: { interval: 100 } }
]);Failure Recovery
Automatic retry mechanisms with configurable backoff strategies. Ensure critical operations complete.
// Configure retry strategy
heliora.setRetryPolicy({
maxAttempts: 5,
backoff: "exponential",
initialDelay: 1000,
maxDelay: 30000
});Gas Management
Intelligent gas pricing and batching to minimize costs. Optimize protocol economics.
// Enable gas optimization
heliora.enableGasOptimization({
batchSize: 10,
maxGasPrice: "50 gwei",
priorityFee: "auto"
});Network Metrics
Live Network Status
Real-time data from Base mainnet RPC. Stats from local database.
Jobs created in this instance
Successfully completed jobs
Currently monitoring conditions
Executed / (Executed + Failed)
Ready to Build Autonomous Protocols?
Deploy execution conditions on testnet. Simulate execution flows. Ship to mainnet when ready.
Early protocol partners onboarding
Production network live on Base Mainnet. Early partners welcome.
Network Access
Execution Access Tiers
Pay for network access. Execution fees and gas paid separately per condition.
Testnet
Development and integration testing
- Base Sepolia testnet
- 100 condition registrations
- 1,000 executions/day
- 5 min condition check interval
- Community Discord support
Mainnet
RecommendedProduction execution access
- Base mainnet
- Unlimited conditions
- 10,000 executions/day
- 1 block condition check interval
- Priority executor assignment
- Webhook notifications
Enterprise
Dedicated infrastructure tier
- Private executor set option
- Unlimited executions
- Custom condition types
- Sub-block latency (MEV integration)
- On-call engineering support
- Security review of conditions
- Value-based pricing (0.1% of liquidation volume)
Pricing Model: Subscription + Execution Fee + Stake
Why this model works:
- Client pays only when execution happens (value-based pricing for liquidations)
- Stake provides cryptoeconomic security — slashed for invalid execution
- Cheaper than keeper networks — no per-keeper fees or committee overhead
- No dependency on Chainlink DON or Gelato infrastructure
Primary execution on Base Mainnet. No custom chain. No protocol token.
Access Control & Execution Keys
Network access is controlled via off-chain issued credentials enforced at the execution layer.
// Access Keys Model
- →Execution Keys are issued off-chain upon tier activation
- →Each key is bound to a specific protocol address
- →Keys define rate limits, execution quotas, and network scope
- →Keys are not tokens — no transfer, no on-chain representation
// Execution Enforcement
- →Condition registration rejected without valid Execution Key
- →Rate limit exceeded: execution queued or dropped per tier policy
- →Revoked keys: immediate execution halt, no pending condition processing
- →All enforcement happens at Heliora execution layer, not on-chain
// Tier-specific Key Behavior
// Security Guarantees
- →Rotation: Keys can be rotated without execution downtime
- →Revocation: Instant key invalidation via control plane
- →Isolation: Protocol A cannot invoke conditions of Protocol B
- →Audit Log: All key operations logged for compliance
⚠ Access to execution network is controlled via off-chain issued credentials. No on-chain staking or slashing is active in this phase.
Technical FAQ
Frequently Asked Questions
Executors post stake proportional to execution value. After execution, there's a 10-block challenge window. Anyone can submit a fraud proof showing the condition was not met at the claimed block. Invalid executions result in full stake slashing — 50% to challenger, 50% burned. This is the same security model used by optimistic rollups.
Open-Source Execution Infrastructure
Core contracts and execution logic are open-source. Review, audit, and contribute.
Stay Updated on Protocol Development
Get updates on new features, network improvements, and execution patterns. Join the developer community.
No spam. Unsubscribe anytime.