Contract Reference

// Execute a standard loop
function performUpdate(address _autoLoopCompatibleContract) external;

// Execute a VRF loop with proof
function performVRFUpdate(
    address _autoLoopCompatibleContract,
    uint256[4] calldata proof,
    uint256[2] calldata uPoint,
    uint256[4] calldata vComponents
) external;

// Controller management
function registerController(address _controller) external;
function removeController(address _controller) external;
function isController(address _address) external view returns (bool);

// Protocol admin
function setBaseFee(uint256 _fee) external;
function setProtocolFeePortion(uint256 _portion) external;
function setMaxGas(uint256 _gas) external;
function withdrawFees(address payable _to) external;

// Register a contract and optionally deposit ETH
function registerAutoLoop(address _contract) external payable;

// Check if a contract implements a supported interface
function isCompatible(address _contract) external view returns (bool);

// Registration status
function isRegistered(address _contract) external view returns (bool);
function getRegisteredContracts() external view returns (address[] memory);

// Balance management
function getBalance(address _contract) external view returns (uint256);
function deposit(address _contract) external payable;
function requestRefund(address _contract, address _to) external;

// Configuration
function getMaxGas(address _contract) external view returns (uint256);
function setMaxGas(address _contract, uint256 _gas) external;

// Verify an ECVRF proof and derive random output
function verify(
    uint256[2] calldata publicKey,  // [pkX, pkY]
    uint256[4] calldata proof,
    uint256[2] calldata uPoint,
    uint256[4] calldata vComponents,
    bytes calldata message
) external pure returns (bool valid, uint256 output);

import "@luckymachines/autoloop/src/AutoLoopCompatible.sol";

contract MyGame is AutoLoopCompatible {
    // Return true when the contract is ready for the next tick
    function shouldProgressLoop() external view override returns (bool) {
        return block.timestamp >= lastTick + INTERVAL;
    }

    // Execute game logic — only callable by AutoLoop
    function progressLoop() external override onlyAutoLoop {
        lastTick = block.timestamp;
        // your logic here
    }
}

import "@luckymachines/autoloop/src/AutoLoopHybridVRFCompatible.sol";

contract MyGame is AutoLoopHybridVRFCompatible {
    function shouldProgressLoop() external view override returns (bool) {
        return block.timestamp >= lastTick + INTERVAL;
    }

    // Called on standard ticks (no VRF)
    function _onTick() internal override {
        turnCount++;
        // Set needsVRF for the NEXT tick
        if (turnCount % 10 == 0) {
            needsVRF = true;
        }
    }

    // Called on VRF ticks (when needsVRF was true)
    function _onVRFTick(uint256[] calldata randomWords) internal override {
        needsVRF = false;
        uint256 lootRoll = randomWords[0] % 100;
        // use randomness
    }
}

import "@luckymachines/autoloop/src/AutoLoopVRFCompatible.sol";

contract DiceGame is AutoLoopVRFCompatible {
    function shouldProgressLoop() external view override returns (bool) {
        return block.timestamp >= lastTick + INTERVAL;
    }

    function progressLoop(uint256[] calldata randomWords) external override onlyAutoLoop {
        lastTick = block.timestamp;
        uint256 roll = randomWords[0] % 6 + 1;
        // use roll
    }
}

// Called by the contract owner or admin
function registerControllerKey(
    address controller,
    uint256 pkX,
    uint256 pkY
) external;

const { secp256k1 } = require("@noble/curves/secp256k1");
const publicKey = secp256k1.getPublicKey(privateKeyHex, false);
const pkX = "0x" + Buffer.from(publicKey.slice(1, 33)).toString("hex");
const pkY = "0x" + Buffer.from(publicKey.slice(33, 65)).toString("hex");

event LoopExecuted(address indexed contract, address indexed controller, uint256 gasCost, uint256 fee);
event ControllerRegistered(address indexed controller);
event ControllerRemoved(address indexed controller);
event FeesWithdrawn(address indexed to, uint256 amount);

event ContractRegistered(address indexed contract, address indexed owner);
event Deposited(address indexed contract, uint256 amount);
event RefundRequested(address indexed contract, address indexed to, uint256 amount);