moire request access
private contract review · robinhood chain

see the risk. keep the code.

moire runs eight fixed checks on your bytecode and lets one AI reviewer read the source, once, with nothing kept. What lands on chain is a seal: a hash, eight answers and a signed opinion. Never a line of your code.

8fixed checks
0bytes of source kept
1signed seal per hash
01 · the idea

two layers. the pattern shows what's hidden.

A moire pattern appears when two grids overlap. Neither grid holds the picture on its own. moire works the same way: a fixed proof layer and an agent layer, kept apart, and the seal is what you see where they meet.

drag to shift the agent layer
01

proof layer

Eight checks run on the compiled bytecode. Every answer is yes or no, the same for anyone who runs it, and bound to the hash of the code.

bytecode8 checksdeterministic
02

agent layer

One AI reviewer reads the source in isolation on a zero-retention route. It describes who holds which powers, scores the risk, never quotes a line, and signs its text as an opinion.

AI reviewerzero retentionsigned opinion
03

the seal

A registry on Robinhood Chain writes both results against the code hash. Wallets, launchpads and bots can read it in one call.

code hashregistryrobinhood chain
02 · how it works

the code goes in. only the seal comes out.

your repocompile + match8 checksAI reviewsignatureseal on chain
  1. 01

    point it at one commit

    A read-only grant on one repo at one commit. moire compiles it and matches the result to the deployed bytecode, byte for byte.

  2. 02

    two layers run apart

    The checks run on the bytecode. The reviewer reads the source alone, writes its notes without quoting, and the working copy is deleted.

  3. 03

    wear the seal

    The seal follows the bytecode wherever it is deployed. Anyone can read it. Nobody can read your code from it.

03 · the proof layer

eight checks. fixed, public, the same for everyone.

01mint

no hidden mint

Supply can only grow through paths the interface declares.

02drain

no owner drain

No address can move balances that are not its own.

03tax

tax under the cap

Any transfer tax is fixed or bounded, and the bound is 10%.

04list

no blacklist

No function can stop a specific address from selling.

05pause

no transfer pause

Transfers cannot be switched off once trading starts.

06proxy

not upgradeable

No proxy and no delegatecall to an address that can change.

07sell

sell path clears

A buy then a sell from a fresh address completes on a fork.

08kill

no self-destruct

Nothing can remove the code after it is sealed.

04 · what anyone can see

the chain reads the answers. never the source.

public, in the seal

  • hashkeccak256 of the runtime bytecode
  • 8 answerswhich checks passed, signed against the hash
  • reviewthe reviewer's signed text, with no quotes from the code
  • reviewerthe key that signed, and which model it used

private, always

  • sourceread once by one reviewer, then deleted
  • reponame, history and branches stay hidden; only the commit hash is noted
  • youno account; the paying wallet is the only identity
05 · the seal

a seal is a list, not a promise.

It says these eight checks ran on this exact bytecode and what they found, and that a named reviewer signed an opinion about it. It does not say the code is good, and it cannot see what the checks do not look for.

the card on the right is an example of the format. it is not a real review.

EXAMPLE
moire sealformat preview
code hash0x0000…0000 chainrobinhood chain reviewerkey + model, listed here risk score0–100
mint
drain
tax
list
pause
proxy
sell
kill

each check shows pass or fail once a review is written.

for holders

hold $MOIRE. skip the queue.

Reviews are rationed: every one runs a compile, a fork simulation and an isolated agent pass. The token decides who goes first. Connect a wallet to link your requests to it, and holder priority is applied automatically once the token is live.

open

anyone

Request access with the form. Reviewed in order of arrival.

standard queue
holder

hold any $MOIRE

Requests from a holding wallet jump ahead of the open queue.

priority queue
builder

larger holders

First in line, more reviews per month, early access to new checks.

front of queue
how the queue orders requests · example
0x8a1f…3c9b · builderfirst
0x41d0…77ae · holdernext
0xc93b…0e12 · holdernext
team@launch.xyz · openafter holders
dev@agent.ai · openafter holders
request access
06 · token

launch with the mark, before the reveal.

$MOIRE launches on Robinhood Chain. The contract address is posted here first. If it is not on this page, it is not ours.

CAposted here first
07 · questions

questions.

does anyone read my code?

One AI reviewer reads it, once, on a route that keeps no prompts or responses. The working copy is deleted when the seal is signed. No person reads it and nothing on chain contains it.

what does a seal actually prove?

The eight answers are bound to the bytecode hash, so anyone can check they belong to that exact code. The review is an opinion and is labelled as one. A seal never says a contract is safe in general.

why two layers instead of one score?

Because a fixed check and an AI opinion are different kinds of evidence. Keeping them apart means a reader always knows which part is proof and which part is judgement.

can a bot read seals?

Yes. A seal is looked up by code hash and returns the eight answers, the score and who signed. One call, no source to parse.

where do I find the token address?

On this page, in the token section and the header, before anywhere else. Ignore addresses posted by anyone else.

when can I submit a contract?

Reviews open at launch. Follow the X account for the date.

walkthrough · sample contracts

see a review, start to seal.

Pick one of three sample contracts and watch what a moire review looks like, from upload to seal.

1 · pick a sample

        
        

want to review your own contract? that opens at launch.

FairLaunch.solready
  1. compile and match bytecode
  2. run 8 fixed checks
  3. agent reads source, zero retention
  4. source deleted
  5. seal signed
example seal ·
0risk score / 100

example result for this sample contract. your own contracts open at launch.

← back to moire

← moire
documentation · v0.9 · pre-launch

how a moire review works.

The full pipeline, from the commit you point at to the seal a wallet reads. This describes the protocol as designed for launch; anything not live yet is marked.

overview

moire produces a seal for a deployed smart contract without publishing its source. A seal is a small onchain record that binds two kinds of evidence to the contract's runtime bytecode hash:

  • proof layer — eight deterministic checks with yes/no answers that anyone can re-derive from the bytecode;
  • agent layer — one written review by an AI auditor agent that reads the source in isolation and signs its output as an opinion.

The two layers are kept separate on purpose. A reader always knows which part is proof and which part is judgement, and the seal never collapses them into a single green tick.

A seal is a list of what was checked, not a guarantee that a contract is safe. It cannot see risks the checks do not look for.

pipeline

Every review runs the same six stages. Each stage writes a log entry; only the last one touches the chain.

  1. intake — a read-only grant on one repository at one commit hash, plus the deployed contract address.
  2. build — the repo is compiled in a sealed container with the exact compiler version and settings from its config.
  3. match — the compiled runtime bytecode is compared to the bytecode at the deployed address (see bytecode matching).
  4. checks — the eight fixed checks run against the matched bytecode and a forked chain state.
  5. review — the source tree is sent once to the auditor agent over a zero-retention route; the agent returns a structured review.
  6. seal — the working copy is destroyed, the results are signed and the seal is written to the registry on Robinhood Chain.
repo@commit ─▶ build ─▶ match ─▶ 8 checks ─┐
                                           ├─▶ sign ─▶ registry (Robinhood Chain)
             source ─▶ agent (ZDR) ─▶ review┘
             source ─▶ deleted

bytecode matching

A review is only meaningful if it describes the code that is actually deployed. moire compiles the submitted commit and compares the result to the onchain runtime bytecode byte for byte, after stripping the metadata hash that compilers append.

  • exact match — review continues.
  • immutable values differ — allowed; positions of immutable variables are masked before comparison.
  • any other difference — the review stops and no seal is written.

The seal records keccak256(runtime bytecode). Because it binds to the code hash and not the address, the same seal applies to every deployment of identical bytecode.

the eight checks

Each check is a fixed rule evaluated on bytecode plus a forked simulation. The rules are public and identical for every contract.

idcheckpasses whenmethod
mintno hidden minttotal supply can only increase through functions declared in the token interfacestatic path analysis on SSTORE to supply slot
drainno owner drainno function moves balances of an address other than msg.sender or an approved spenderstatic + fork call with privileged keys
taxtax under the capany transfer fee is fixed or has a hard upper bound of 10%bound search on fee variables
listno blacklistno function can make transfers from a specific address revertstatic analysis of revert conditions keyed on addresses
pauseno transfer pausetransfers cannot be disabled globally after trading opensstatic + fork toggle test
proxynot upgradeableno DELEGATECALL to an address that can change after deployopcode scan + storage slot analysis (EIP-1967 and custom)
sellsell path clearsa buy followed by a sell from a fresh address succeeds on a fork of current statefork simulation against the main pool
killno self-destructthe code cannot be removed or replacedopcode scan for SELFDESTRUCT and reachable CREATE2 redeploy

Checks are answered pass, fail or n/a (for example, tax on a contract with no fee logic). At launch the answers are signed by the reviewer key; proving them inside a zkVM is on the roadmap, and the seal states which method produced them.

agent layer

The agent layer answers questions the fixed checks cannot: what the contract is for, who holds which powers, and whether anything looks deliberately misleading — a helper named like routine upkeep that mints, a fee recipient that can be swapped, an owner function with an unusual side effect.

what the agent returns

  • a plain-language summary of what the contract does;
  • a list of privileged roles and what each can change;
  • flagged patterns with a short reason, written without quoting code;
  • a risk score from 0 to 100 (see risk score).

rules the agent works under

  • It never quotes a line of source. Output is filtered for code fragments before signing.
  • It sees one repository at one commit and nothing else.
  • Its output is labelled opinion in the seal and is never merged into the eight answers.
  • The model identifier is recorded in the seal so readers know what wrote the review.

privacy model

The point of moire is that a contract can be checked without its source becoming public. The design limits who touches the source and for how long.

datawho sees ithow long
source treethe build container and the auditor agentone review; deleted before the seal is signed
agent promptthe model, over a zero data retention routenot stored by the route
repo name, historynobody outside the build containernever recorded
commit hashpublic, in the sealpermanent
check answers, reviewpublic, in the sealpermanent

No account is required to read seals. Requesting a review needs contact details for the access queue; those are used only to contact you about your request.

seal format

A seal is one record in the registry contract, keyed by code hash.

struct Seal {
  bytes32  codehash;     // keccak256 of runtime bytecode
  bytes20  commit;       // git commit the review compiled
  uint8    checks;       // bitmask: 8 checks ran
  uint8    passed;       // bitmask: which passed
  uint8    score;        // agent risk score 0–100
  bytes32  reviewHash;   // hash of the signed review text
  address  reviewer;     // signing key
  uint64   sealedAt;     // block timestamp
  uint8    method;       // 0 = signed, 1 = zk-proven
}

The full review text is stored off-chain at a content address matching reviewHash, so anyone can verify it was not edited after sealing.

reading seals

Wallets, launchpads and trading agents read seals with one call. No source, no report parsing.

// onchain
registry.sealOf(codehash) → Seal

// http (planned)
GET /v1/seal/{codehash}
{
  "passed": ["mint","drain","list","pause","proxy","kill"],
  "failed": ["tax","sell"],
  "score": 46,
  "reviewer": "0x…",
  "method": "signed"
}

An integrator should show the failed checks first and the score second. A high score with no failed checks means the agent found something the fixed checks do not cover; read the review.

risk score

The agent's score is an opinion on a 0–100 scale. It is calibrated against a labelled set of known-good and known-malicious contracts and reported in bands:

bandscoretypical meaning
low0–30standard patterns, few or no privileged powers
medium31–60owner powers that can change economics, such as an unbounded fee
high61–100powers that can block selling, mint supply or move user funds

limits

  • The checks cover eight specific failure modes. Economic attacks, oracle manipulation and off-chain admin keys are out of scope.
  • A seal describes code at one moment. It says nothing about who controls privileged keys later.
  • The agent can be wrong. That is why its output is labelled as opinion and kept apart from the proof layer.
  • Contracts whose source cannot be compiled to match the deployed bytecode cannot be sealed.

token & access

Reviews cost real compute: a build, a fork simulation and an agent pass each. Access is queued, and $MOIRE sets the order.

  • open queue — anyone can request access with the form.
  • holder priority — requests linked to a wallet holding the token are reviewed ahead of the open queue.
  • builder tier — larger holders get the front of the queue, more reviews per month and early access to new checks.

Link a wallet when you request access. Priority is read from the wallet's balance at review time, once the token is live. Thresholds for each tier are published here before launch.

glossary

codehashkeccak256 of a contract's runtime bytecode; the key a seal is stored under
ZDRzero data retention; a model route that does not store prompts or outputs
forka local copy of chain state used to simulate transactions without sending them
proof layerthe eight deterministic checks
agent layerthe AI auditor's signed written review
registrythe contract on Robinhood Chain that stores seals
← moire
request access

get your contract in the queue.

Tell us what you are building. Requests are reviewed by the team; linking a wallet that holds $MOIRE moves you into the priority queue.

no wallet linked · open queue

✓

request received.

It's on review. You can follow it on your account page.

open account
← moire
account

your requests.

wallet

addressnot connected queueopen priorityapplies when the token is live

requests are stored in this browser. use the same browser to follow them.