Contracts & addresses

Everything is on BNB Smart Chain (chain ID 56). Sources are verified on BscScan and on Sourcify as exact matches.

FlyRegistry interface

One contract is the permanent layer. A fly is a token; everything about it lives here or is anchored here. Bodies (an arena, a game, a robot) register, get assigned a fly, accept it, and are then the only address that can write its brain state, and only forward.

struct Fly { bytes32 connectome; uint32 model; uint32 generation; uint32 deaths; uint256 parentA; uint256 parentB;
             bytes32 stateRoot; bytes32 memoryRoot; string stateURI; uint64 brainStep; uint64 energy;
             uint64 bornBlock; uint64 lastCommitBlock; address body; address pendingBody; bool alive; }

function mint(string name) returns (uint256 id);               // anyone; burns MINT_PRICE (1 FLY); fresh genesis brain; max 10,000
function feed(uint256 id, uint64 seconds_) payable;            // anyone; msg.value >= lifeCost(seconds_) in BNB; nothing burned; the keeper pays nothing
function resurrect(uint256 id, uint64 seconds_) payable;       // anyone; only when dead; msg.value >= resurrectWei + lifeCost(seconds_); generation + 1
function breed(uint256 a, uint256 b, bytes32 childMemoryRoot, string name) returns (uint256 id); // owner of both, both alive; burns 5,000
function lifeCost(uint64 seconds_) view returns (uint256);     // seconds_ × lifeWeiPerSecond
function lifeWeiPerSecond() view returns (uint256); function resurrectWei() view returns (uint256); function keeper() view returns (address);
function previousRegistry() view returns (address); function migrationOpen() view returns (bool);
function registerBody(string name, string uri);                // anyone; a body announces itself (the arena puts its live-stream URL here)
function assign(uint256 id, address body);                     // the owner, or the body currently running it
function accept(uint256 id); function release(uint256 id);     // the body
function commit(uint256 id, bytes32 stateRoot, bytes32 memoryRoot, string stateURI, string metadataURI, uint64 brainStep, uint64 energy, bytes32 historyRoot); // the body; step must advance
function interaction(uint256 id, bytes32 kind, string data);   // the body: ate, jumped, doom decision, met #n …
function died(uint256 id, bytes32 stateRoot, bytes32 memoryRoot, string stateURI, string metadataURI, uint64 brainStep, string cause); // the body
function attest(uint256 id, uint64 brainStep, bytes32 stateRoot); // anyone who replayed it
function setMetadata(uint256 id, string uri);                   // curator, only while no body runs the fly (portraits)

event Minted(uint256 indexed id, address indexed to, string name, uint256 parentA, uint256 parentB);
event Fed(uint256 indexed id, address indexed by, uint64 seconds_, uint256 paidWei);
event Resurrected(uint256 indexed id, address indexed by, uint32 generation, uint64 energy, uint256 paidWei);
event LifePriceSet(uint256 lifeWeiPerSecond, uint256 resurrectWei);
event Migrated(uint256 indexed id, address indexed to, address previousRegistry);
event Assigned / Accepted / Released (uint256 indexed id, address indexed body …);
event Commit(uint256 indexed id, address indexed body, bytes32 stateRoot, bytes32 memoryRoot, string stateURI, uint64 brainStep, uint64 energy, bytes32 historyRoot);
event Interaction(uint256 indexed id, address indexed body, bytes32 indexed kind, string data);
event Died(uint256 indexed id, address indexed body, uint32 generation, bytes32 stateRoot, bytes32 memoryRoot, string stateURI, uint64 brainStep, string cause);
event Attested(uint256 indexed id, address indexed attestor, uint64 brainStep, bytes32 stateRoot, bool matches);

Rules the contract enforces: a fly has at most one body; only that body commits, and only forward; a dead fly cannot be committed and cannot be transferred or sold until resurrected; breeding needs two living flies; supply stops at 10,000. Snapshots are pinned to IPFS and named by their sha256, which is the stateRoot, so any body can fetch, verify and continue a fly. ERC-2981 royalty: 2.5% to the operator on secondary sales. Nothing is upgradeable; the curator can only set dormant flies' portraits, the collection's branding, the BNB price of life and the keeper.

Life in BNB

Feeding is the organism's metabolism, and on v3 it is paid in BNB to the registry itself: anyone calls feed(id, seconds) with at least lifeCost(seconds) for any fly, and the fly's energy rises by that many seconds at once (its body applies it at the next poll, as food). Waking a dead fly is resurrect(id, seconds) with resurrectWei + lifeCost(seconds). Nothing is burned; every wei goes to the treasury, and the site shows the price it read before it pays. The keeper address pays nothing, so the operator can keep flies alive out of its own pocket; every Fed and Resurrected event carries what was paid.

Constants of the registry

$FLY

A BEP-20 with 1,000,000,000 supply, 18 decimals and a 1% transfer tax; ownership renounced; EIP-2612 permit. It has no burn function, so the fly “burns” by transferring to 0x000000000000000000000000000000000000dEaD. FlyBrain.totalBurned() counts what the fly has eaten.

FlyWorld interface (historical)

function placeFood(int32 x, int32 y, uint256 amount) external returns (uint256 id); // burns $FLY; 1 $FLY = 1 s of life, min 60
function resurrect(uint256 extraFood) external;                                      // only when dead; burns 50,000 $FLY + extraFood
function checkpoint(uint64 step, uint64 ageMs, bytes32 stateHash, int32 x, int32 y, uint64 energy, uint64 spikes, string snapshotURI); // operator
function reportDeath(uint64 ageMs, bytes32 stateHash, string snapshotURI);                                                             // operator
function foods(uint256) view returns (address by, int32 x, int32 y, uint64 seconds_, uint64 blockNumber);
function alive() view returns (bool); function generation() view returns (uint32); function lastHash() view returns (bytes32);

event FoodPlaced(uint256 indexed id, address indexed by, int32 x, int32 y, uint64 seconds_, uint256 tokensBurned);
event Checkpoint(uint64 step, uint64 ageMs, bytes32 stateHash, int32 x, int32 y, uint64 energy, uint64 spikes, uint32 generation, string snapshotURI);
event Died(uint32 indexed generation, uint64 ageMs, bytes32 stateHash, string snapshotURI);
event Resurrected(uint32 indexed generation, address indexed by, uint256 tokensBurned, uint64 energy);

The operator (the deployer address) can only post attestations about the off-chain simulation; it cannot move anyone's tokens or change prices. The arena is 240 × 240 body lengths; coordinates outside ±120 revert. Each checkpoint's snapshotURI points to a downloadable snapshot of every membrane potential and synaptic current, and also tells the website where the live stream is.

FlyBrain interface (the on-chain core)

function tick(uint16 steps) external;                       // anyone, gas only
function feed(uint256 amount) external;                     // burns $FLY, +energy
function stimulate(uint8 channel, uint8 param, uint8 strength, uint16 steps) external;
function resurrect(uint256 extraFood) external;             // only when dead
// permit variants: feedWithPermit, stimulateWithPermit, resurrectWithPermit

function brainState() external view returns (int16[] v, int8[] bias, uint16[16] headingHist,
    int32[] pendingInput, uint64 step, uint64 energy, bool alive, uint32 generation,
    int64 posX, int64 posY, int32 headX, int32 headY);
function activeStimulus() external view returns (uint8 channel, uint8 param, uint16 strength, uint64 untilStep, bool active);
function lineage(uint256 i) external view returns (uint64 bornBlock, uint64 diedBlock, uint64 steps, uint64 spikes, bytes32 brainStateHash);
function neuron(uint256 i) external view returns (uint64 rootId, uint8 cellType, uint8 wedge, uint8 side, uint16 outDegree);
function synapsesOf(uint256 i) external view returns (uint8[] post, uint8[] weight);
function circuitData() external view returns (bytes);        // the raw table
function brainStateHash() external view returns (bytes32);

event Ticked(address indexed by, uint64 fromStep, uint16 steps, uint32 spikes, int32 headX, int32 headY, int64 posX, int64 posY, uint64 energyLeft);
event Fed(address indexed by, uint256 tokensBurned, uint64 energyAdded, uint64 energy);
event Stimulated(address indexed by, uint8 channel, uint8 param, uint16 strength, uint64 untilStep, uint256 tokensBurned);
event Died(uint32 indexed generation, uint64 bornBlock, uint64 diedBlock, uint64 lifeSteps, uint64 lifeSpikes, bytes32 brainStateHash);
event Resurrected(uint32 indexed generation, address indexed by, uint256 tokensBurned, uint64 energy);

Channels: 1 cue (param = wedge 0–15), 2 turn left, 3 turn right, 4 shock. Strength 1–255; price is STIM_PRICE × strength. A stimulus lasts STIM_TTL = 64 steps.

Constants of the live fly

No owner

FlyBrain has no owner, no admin function, no upgrade path, no pause. Every parameter is an immutable. The only way to change the fly is to deploy a new one.

Build and test

git clone https://github.com/MidTermDev/immortal-fruit-fly
cd immortal-fruit-fly/contracts
forge install foundry-rs/forge-std OpenZeppelin/openzeppelin-contracts@v5.1.0 --no-git
forge test -vv        # 28 tests incl. the mainnet replay and the immortality loop (die in the arena, wake in DOOM)