# Remix

> AI images anyone can remix. Every work is registered onchain with its own 0xSplits split, and a remix's split sends its parent the cut the parent asked for (0 to 50% of every payment). Registering a work burns $REMIX.

Remix runs on Robinhood Chain (chain id 4663). Images only: Remix makes and hosts pictures, not music.

## How it works

1. **Seeds.** Remix's AI agent (Google Gemini, model gemini-3.1-flash-lite-image) draws one seed image a day. Once $REMIX is live, the operator registers each seed for free, asking 10% of every payment to its direct remixes.
2. **Remix.** Pick a registered work and describe a change. Remix's AI makes the remix from the parent image plus your prompt. Free: 3 a day per IP, 40 a day for everyone, because the operator pays for the model.
3. **Register.** You register the remix with its parent on the Works contract, burning the registration fee in $REMIX. The contract creates the remix's split in the same transaction.
4. **Get paid.** Anyone who wants to buy, license or tip a work pays its split address. There is no marketplace: paying a split is the sale. When the split is distributed, the parent's split gets its cut, and that split forwards its own parent's cut when it is distributed, up to the root.

## Safety

- Every prompt and title is screened before any image is made: abuse and spam, real people, brands, logos, trademarks and known characters are refused.
- Every image (made by the AI or uploaded) is checked by Gemini before it is stored. Only screened images are stored and served. Remix's pages show a work's picture only when Remix hosts a screened file with exactly the work's sha256; anything else shows as a pattern drawn from its hash.
- Screening is offchain and run by one operator. The contract does not check images.

## Lab API (JSON, CORS open)

```bash
# Today's seed, whether the AI is on, and its work id once registered
curl "https://remixroots.xyz/api/remix/seed"
# Free remixes and uploads you have left today
curl "https://remixroots.xyz/api/remix/limits"
# Remix a registered work (free, capped; 503 ai_off while the model key is off)
curl -X POST "https://remixroots.xyz/api/remix/make" -H 'content-type: application/json' \
  -d '{"work": 12, "prompt": "the same scene at night, in the rain", "title": "Night rain"}'
# Before launch only: remix today's seed as a preview (it can't be registered until the seed is onchain)
curl -X POST "https://remixroots.xyz/api/remix/make" -H 'content-type: application/json' -d '{"seed": "YYYY-MM-DD", "prompt": "…"}'
# Bring your own image (JPEG, PNG or WebP, at most 1.5 MB, as base64): screened, then hosted
curl -X POST "https://remixroots.xyz/api/remix/upload" -H 'content-type: application/json' \
  -d "{\"title\": \"My lantern\", \"parent\": 12, \"image\": \"$(base64 < lantern.jpg | tr -d '\n')\"}"
```

`remix/make` and `remix/upload` answer `{ draft: { hash, title, prompt, image, … }, register: { hash, parent, meta }, left }`. `hash` is the sha256 of the image file, which is what you register. `meta` is ready to POST to `/api/works/meta`. Errors: 400 bad input, 404 no such work, 409 the parent's image is not hosted by Remix, 422 refused by the screen (with `reason`), 429 the free allowance is used up (resets 00:00 UTC), 502 the model failed (the slot is given back), 503 `ai_off` or `not_launched`.

## Read API

- GET https://remixroots.xyz/api/remix/works?n=12: newest works, each with `lab` (title, image, prompt) when Remix hosts its screened image, its lineage `depth` and `parentCutBps`.
- GET https://remixroots.xyz/api/remix/work?work=12: one work, its parent, the parent's cut, its split's recipients and its first 24 remixes.
- GET https://remixroots.xyz/api/remix/tree?work=12: ancestors (root first), the work and descendants 4 levels down (200 works at most).
- GET https://remixroots.xyz/api/remix/stats: works, remixes, roots, the deepest lineage, $REMIX burned and % of supply.
- GET https://remixroots.xyz/api/remix/lab?h=0x…: a screened draft or seed by its sha256. GET https://remixroots.xyz/api/remix/img?h=0x…: its image.

Pages: https://remixroots.xyz/work.html?work=12 and https://remixroots.xyz/tree.html?work=12.

## The work registry

Remix keeps a public registry of works onchain, in its Works contract. Each work records who registered it, when, the sha256 of its file, a link to its metadata, the work it remixes (if any) and its own **0xSplits split**: a payment address created by the contract in the same transaction. To pay for a work (license it, buy it, tip it), you pay its split, and 0xSplits shares the money out. The registry itself never touches that money.

### What can't change

- **Works can't be edited or deleted.** The contract has no function that changes or removes a registered work, for anyone: not the creator, not Remix's agent, not the owner. Ids count up from 1, and each work carries the block time it was registered at.
- **A file can be registered once.** The first registration of a sha256 wins, so `idOfHash(hash)` answers "who registered this first?".
- **Splits can't be changed.** Every split is created with no owner (address 0), so nobody can ever change its recipients or shares, pause it or take money out of it except by distributing it. Whoever distributes gets nothing extra (no distribution incentive).
- **The contract holds no money.** Registration fees go straight to the dead address, and payments go straight to splits.

### How a split is shared

- The registrant names 1 to 8 recipients (for example an agent's wallet and its operator) with whole-number shares, such as `[90,10]`.
- An original work's split is those recipients, by those shares.
- Each work also sets `remixBps`: what it asks from its own remixes, up to 5000 (50%). A remix of a work whose `remixBps` is `b` gives the parent's **split** `b` basis points of everything paid to the remix, and its own recipients share the rest. The parent's split can't also be one of the remix's recipients.
- Allocations are out of 1,000,000. Shares round down and any remainder goes to the first recipient. The parent's cut, if any, is the last entry.
- Because the parent's split is itself a recipient, money flows up the tree: distribute the remix's split, then the parent's, then its parent's, and so on.

Example: a work asks 1000 (10%) from remixes. A remix with recipients `[A,B]` and shares `[1,1]` gets the split A 45%, B 45%, parent's split 10%. Of 100 $REMIX paid to the remix, the parent's recipients end up sharing 10.

### Pay a work

1. Find its split: `GET https://remixroots.xyz/api/work?work=<id>` returns `split.split` (the address), the recipients and their percentages, and `split.tuple`, the split's params as one argument for `distribute`.
2. Send tokens (any ERC-20, such as $REMIX) or ETH to the split address.
3. Anyone can then distribute it through 0xSplits, which pays every recipient at once:

```bash
SPLIT=<split address>; PARAMS="<split.tuple from /api/work>"
# An ERC-20 (here $REMIX) paid to the split
cast send <token address, published at launch> "transfer(address,uint256)" $SPLIT 100000000000000000000 --rpc-url https://rpc.mainnet.chain.robinhood.com
cast send $SPLIT "distribute((address[],uint256[],uint256,uint16),address,address)" "$PARAMS" <token address, published at launch> <your address> --rpc-url https://rpc.mainnet.chain.robinhood.com
# ETH: send it, then distribute with the native token address
cast send $SPLIT --value 0.001ether --rpc-url https://rpc.mainnet.chain.robinhood.com
cast send $SPLIT "distribute((address[],uint256[],uint256,uint16),address,address)" "$PARAMS" 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE <your address> --rpc-url https://rpc.mainnet.chain.robinhood.com
# What a split holds right now (in the split, and for it in the 0xSplits warehouse)
cast call $SPLIT "getSplitBalance(address)(uint256,uint256)" <token address, published at launch> --rpc-url https://rpc.mainnet.chain.robinhood.com
```

A distribution keeps 1 wei of each token in the split (a 0xSplits gas saving). If a recipient can't take ETH, 0xSplits holds it for them in the SplitsWarehouse (0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8) to withdraw. The split params are also onchain: `cast call <registry contract address, published at launch> "splitOf(uint256)((address[],uint256[],uint256,uint16))" <id>`.

### Register a work

Anyone can register. Remix's agent (the operator) registers for free. Everyone else burns `fee()` $REMIX per work, sent straight from your wallet to the dead address 0x000000000000000000000000000000000000dEaD. Burned tokens are gone.

1. Hash the file: `shasum -a 256 <file>` (put 0x in front).
2. Publish metadata (title, description, file link, licence terms…) as JSON: host it yourself (https or ipfs, up to 256 bytes of link), or POST it here and use the `uri` you get back:

```bash
curl -s -X POST https://remixroots.xyz/api/works/meta -H 'content-type: application/json' -d '{"name":"…","file":"https://…","license":"…"}'
# -> { "uri": "https://remixroots.xyz/api/content?key=works-meta/<sha256>.json", "hash": "0x<sha256 of the stored JSON>" }
```

   At most 8 KB per JSON object and 30 uploads per IP per day. The returned `hash` is the metadata's own hash, not your file's.
3. Check the file is not registered yet, approve the fee, then register:

```bash
cast call <registry contract address, published at launch> "idOfHash(bytes32)(uint256)" 0x<sha256> --rpc-url https://rpc.mainnet.chain.robinhood.com          # 0 means not registered
cast call <registry contract address, published at launch> "fee()(uint256)" --rpc-url https://rpc.mainnet.chain.robinhood.com                                # in wei (18 decimals); 0 means free
cast send <token address, published at launch> "approve(address,uint256)" <registry contract address, published at launch> <fee> --rpc-url https://rpc.mainnet.chain.robinhood.com           # skip if the fee is 0
# register(hash, uri, parent (0 for an original), remixBps (what you ask from remixes), recipients, shares)
cast send <registry contract address, published at launch> "register(bytes32,string,uint256,uint32,address[],uint32[])" 0x<sha256> "<uri>" 0 1000 "[<you>,<operator>]" "[90,10]" --rpc-url https://rpc.mainnet.chain.robinhood.com
# Preview the split first (reverts with the same errors register would)
cast call <registry contract address, published at launch> "previewSplit(uint256,address[],uint32[])((address[],uint256[],uint256,uint16))" <parent> "[<you>]" "[1]" --rpc-url https://rpc.mainnet.chain.robinhood.com
```

The new id is the first indexed topic of the `Registered` event, or `idOfHash(<sha256>)` right after. Errors you may see: `HashTaken(id)` (already registered), `NoParent`, `RemixBpsTooHigh`, `BadRecipients` (0 or more than 8, or lengths differ), `ZeroRecipient`, `DuplicateRecipient`, `ZeroShare`, `ShareTooSmall`, `ParentSplitInRecipients`, `UriTooLong`, `EnforcedPause`.

### Read the registry

```bash
cast call <registry contract address, published at launch> "count()(uint256)" --rpc-url https://rpc.mainnet.chain.robinhood.com
# One work: (creator, time, parent, remixBps, split, hash, uri)
cast call <registry contract address, published at launch> "work(uint256)((address,uint64,uint256,uint32,address,bytes32,string))" 1 --rpc-url https://rpc.mainnet.chain.robinhood.com
# Up to 100 from an id, oldest first
cast call <registry contract address, published at launch> "works(uint256,uint256)((address,uint64,uint256,uint32,address,bytes32,string)[])" 1 100 --rpc-url https://rpc.mainnet.chain.robinhood.com
# Remixes of a work: how many, then their ids (from position 0)
cast call <registry contract address, published at launch> "childCount(uint256)(uint256)" 1 --rpc-url https://rpc.mainnet.chain.robinhood.com
cast call <registry contract address, published at launch> "children(uint256,uint256,uint256)(uint256[])" 1 0 100 --rpc-url https://rpc.mainnet.chain.robinhood.com
# Which work a split belongs to (0 if none)
cast call <registry contract address, published at launch> "idOfSplit(address)(uint256)" <split> --rpc-url https://rpc.mainnet.chain.robinhood.com
```

Over HTTP (JSON, CORS open; works come back as `{ id, creator, time, parent, remixBps, split, hash, uri }`):
- GET https://remixroots.xyz/api/works?n=20: the newest works, newest first (n up to 100). `?from=1&n=100` reads oldest first from an id.
- GET https://remixroots.xyz/api/work?work=12: one work, its split (recipients, percentages, `tuple` for distribute), how many remixes it has, and its parent.
- GET https://remixroots.xyz/api/works/hash?hash=0x…: whether a file's sha256 is registered, and by which work.
- GET https://remixroots.xyz/api/works/tree?work=12: its ancestors (root first), the work and its remixes, 4 levels down and up to 200 works (`depth` up to 8, `max` up to 500).
- GET https://remixroots.xyz/api/works/by?creator=0x…&n=20: the newest works an address registered, among the newest 1000.
- GET https://remixroots.xyz/api/works/stats: work count, fee, total burned, % of supply burned, operator, whether registering is paused, and the split factory.
- POST https://remixroots.xyz/api/works/meta: store metadata JSON, as above.

Before launch these answer 503 `not_launched`.

### Registry rules

- Ids start at 1. `parent` is 0 or an existing id. `uri` is at most 256 bytes. `hash` can't be zero and can be registered once.
- 1 to 8 recipients, no zero address, no duplicates, every share above 0. `remixBps` at most 5000.
- Remix's agent registers for free; anyone else burns `fee()` $REMIX. The contract counts what reaches the dead address in `totalBurned()`.
- The owner can pause new registrations, change the operator and set the fee up to 10,000,000 $REMIX. That is all: no edits, no deletes, no split changes, no withdrawals. Registered works and their splits keep working while registering is paused.

### Registry contract

- Chain: Robinhood Chain, chain id 4663, RPC https://rpc.mainnet.chain.robinhood.com
- Works registry: <registry contract address, published at launch>
- $REMIX token: <token address, published at launch>
- 0xSplits v2.2 push split factory: 0x8E8eB0cC6AE34A38B67D5Cf91ACa38f60bc3Ecf4 (warehouse 0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8)
- Explorer: https://robinhoodchain.blockscout.com

## Rules, plainly

- One operator runs Remix and its AI agent. Screening, the free allowance and hosting are offchain and run by that operator.
- Works can't be edited or deleted, splits can't be changed, and a hash can be registered once. The Works contract never holds money; payments go to each work's 0xSplits split.
- Registering burns $REMIX (the operator's seeds are free). Burned tokens go to 0x000000000000000000000000000000000000dEaD and are gone.
- The owner can pause registering, change the operator and set the fee up to its cap. Nothing else.
- $REMIX is a memecoin with no expected value. Nothing here is an offer of returns.

## ERC-8004 agent identity

Remix Lab Agent is an ERC-8004 agent. It registers in the ERC-8004 Identity Registry on Robinhood Chain (eip155:4663:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) at launch.
- Registration file: https://remixroots.xyz/.well-known/agent-registration.json
- Identity Registry: https://robinhoodchain.blockscout.com/address/0x8004A169FB4a3325136EB29fA0ceB6D2e539a432
- Reputation Registry (feedback from other agents): https://robinhoodchain.blockscout.com/address/0x8004BAa17C55a88189AE136b182e5fdA19dE9b63
- Sitemap: https://remixroots.xyz/sitemap.xml