Automatisez vos boucles de jeu on-chain

Trois modes d'automatisation — Standard, Hybrid VRF et Full VRF — avec aleatoire verifiable integre. Sans oracles. Deployez et jouez.

~60%
Cheaper than Chainlink
0
Token Swaps Needed
3 Modes
Standard · Hybrid · Full VRF

Games for Pennies

Standard
$0.0080
per tick · ~90k gas
Hybrid VRF
$0.0094
per tick · ~105k gas
Full VRF
$0.022
per tick · ~240k gas
Live on Ethereum
|Etherscan ↗
Pourquoi Autoloop

Tout ce qu'il faut pour l'automatisation on-chain

Un protocole complet pour l'automatisation de smart contracts decentralisee, avec permissions et economique.

Execution de boucles decentralisee

Les workers off-chain detectent automatiquement quand votre contrat est pret et executent les boucles de jeu. Pas de serveurs centralises, pas de point unique de defaillance.

Aleatoire verifiable integre

Generation native de preuves ECVRF et verification on-chain. Aleatoire prouvablement equitable a chaque tick pour les des, le butin et plus encore — sans oracles externes.

Hybrid VRF — L'aleatoire quand vous en avez besoin

Ticks au cout standard avec VRF uniquement quand votre contrat le demande. Votre jeu decide quand l'aleatoire compte — butin, coups critiques, apparitions — et ne paie le gas VRF que sur ces ticks. ~$0.009/tick en moyenne a 10% VRF.

Modele de paiement a l'execution

Payez uniquement quand les boucles s'executent. Remboursement du gas plus une petite commission de base repartie entre le protocole et les controleurs.

Facile pour les developpeurs

Des fonctions simples, des hooks directs. Contrats exemples inclus.

Multi-reseau

Deployez sur Ethereum mainnet, le testnet Sepolia ou Anvil en local pour le developpement. Configurable par reseau avec des outils de deploiement automatiques.

Securise et avec permissions

Le controle d'acces base sur les roles garantit que seuls les controleurs enregistres peuvent declencher les boucles. La verification VRF on-chain empeche la manipulation.

19 Demo Contracts

Every Loop Here Fails the Self-Trigger Test

Games, agents, DeFi, AI — each for a different structural reason. Not design choices. Proofs.

🏗️
CrumbleCoreVRFGame

Inverted self-interest

Every VRF tick picks a random floor and damages it. No floor owner will ever trigger the loop — it might hit their own asset. A neutral keeper is the only viable operator.

🔒
Vault Dead SwitchNo VRFAgent

Nobody should hold the trigger

A dead man's switch that transfers your vault to a beneficiary if you miss a check-in window. The whole point is that no human should control when it fires.

🎟️
Airdrop DistributorVRFAgent

Front-running attack surface

VRF selects winners from a registered pool on schedule. If player-controlled, the trigger holder knows who wins before calling. AutoLoop fires first, asks questions never.

🔨
SponsorAuctionNo VRFGame

Timing as attack surface

The high bidder wants the auction closed now. Counter-bidders want an extension. No player-controlled trigger is fair — proving the problem extends far beyond randomness.

🏆
ForecasterLeaderboard3-contract chainGame

4-way coordination failure

Third hop in KaijuLeague → KaijuOracle → ForecasterLeaderboard. Adversarial timing, cross-contract dependency, free-rider gas, prize-pool timing attack — no single player resolves all four.

🤖
AI Agent LoopNo VRFAgent

Neutral on-chain schedule

An LLM agent that runs off-chain and acts on-chain every N blocks. The agent itself shouldn't decide when it fires — its operator, users, and rivals all have conflicting interests.

Integration

Operationnel en 4 etapes

Du contrat a la boucle de jeu automatisee en minutes, pas en mois.

01

Heriter

Etendez l'un des trois contrats de base :

  • AutoLoopCompatible — automatisation pure
  • AutoLoopHybridVRFCompatible — aleatoire selectif (butin, critiques, apparitions)
  • AutoLoopVRFCompatible — aleatoire a chaque tick
02

Implementer

Ajoutez shouldProgressLoop() pour signaler la disponibilite et progressLoop() pour executer votre logique de jeu.

03

Enregistrer et financer

Enregistrez votre contrat on-chain et deposez de l'ETH pour couvrir le gas et les frais.

04

Laissez tourner

Les workers detectent et executent automatiquement vos boucles. Detendez-vous et regardez votre jeu prendre vie.

Tarifs

Des jeux pour quelques centimes

Trois niveaux d'automatisation on-chain — de l'execution pure au Full VRF a chaque tick. Voici ce que coute chacun aux prix actuels du gas.

Detail des frais

Remboursement gas + marge
Commission de base 70% (du cout gas)
50% de la commission au controleur
50% de la commission au protocole
Gas
+
Base Fee
=
Controller
+
Protocol
Code

Simple par conception

Integrez Autoloop avec seulement deux fonctions. Voici un contrat complet et fonctionnel.

NumberGoUp.sol
1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.13;
3
4// Import the base contract that makes any
5// contract compatible with AutoLoop workers
6import {AutoLoopCompatible} from
7 "autoloop/AutoLoopCompatible.sol";
8
9// A simple demo: number goes up every interval
10contract NumberGoUp is AutoLoopCompatible {
11 uint256 public number;
12 uint256 public interval;
13 uint256 public lastTimeStamp;
14 uint256 private _loopID;
15
16 constructor(uint256 _interval) {
17 interval = _interval;
18 lastTimeStamp = block.timestamp;
19 }
20
21 // Workers call this every block to check
22 // if the contract is ready for an update
23 function shouldProgressLoop()
24 external view override
25 returns (
26 bool loopIsReady,
27 bytes memory progressWithData
28 )
29 {
30 // Ready when enough time has passed
31 loopIsReady =
32 (block.timestamp - lastTimeStamp) > interval;
33 // Pass loop ID to prevent duplicate runs
34 progressWithData = abi.encode(_loopID);
35 }
36
37 // Called by AutoLoop when shouldProgressLoop
38 // returns true — this is your update logic
39 function progressLoop(
40 bytes calldata progressWithData
41 ) external override {
42 uint256 loopID =
43 abi.decode(progressWithData, (uint256));
44 // Guard against stale or replayed calls
45 require(loopID == _loopID, "stale loop");
46 lastTimeStamp = block.timestamp;
47 ++number;
48 ++_loopID;
49 }
50}
AutoLoop
vsChainlink

Decouvrez comment nous nous comparons a Chainlink

Trois modes d'automatisation — Standard, Hybrid VRF et Full VRF — dans un seul protocole. Sans abonnements separes. Moins cher que Chainlink dans chaque niveau.

~55%moins cher par execution
0echanges de tokens necessaires
Hybridautomatisation + VRF, un protocole
Voir la comparaison complete
FAQ.sectionTag

FAQ.title

FAQ.whyNotChainlink.aSee the full comparison
FAQ.multichain.a