The chain is a notebook.
premise
Every transaction carries a field nobody reads. We read it.
Robinhood Chain is an Arbitrum Nitro rollup. Its sequencer orders transactions, its batches are compressed and posted to Ethereum, and every byte of calldata inside those batches inherits Ethereum's finality. A 32-byte digest placed in that field is therefore a timestamped, replicated, publicly auditable fact: this hash existed no later than this block.
0 contracts
1 transaction
∞ readers
STRATA is a convention, not a platform. It defines a fixed byte layout for the data field, a sink address every record is addressed to, and a deterministic way to recompute the digest so anyone can check it. There is no server, no account, no token and no admin key. The record is the transaction itself.
Because the sink is a plain address with no code, sealing costs the base transaction fee plus a few dozen bytes of calldata. At current Robinhood Chain gas that is a fraction of a cent. Because the sink has no key, nothing can ever be moved, censored or edited after the fact: the index is the chain's own transaction history.
Everything on this page runs in your browser against a public RPC node. Your files never leave the tab. Only their fingerprint goes on chain.
Layers below: compute a digest → seal it from your wallet → verify any seal against the chain → browse the ledger → watch the substrate → read the spec.
digest
Nothing leaves this tab. Only the fingerprint does.
Drop any file, or type. Your browser computes a keccak-256 digest locally. Drop several files and STRATA builds a sorted-pair Merkle tree over them, so a single 32-byte root commits to the whole set and each file gets its own inclusion proof.
treesorted-pair
uploadsnone
networknone
seal
Press it into the record.
Connect a wallet. STRATA composes a 38-byte payload, magic, version, kind and digest, and sends it as a zero-value transaction to the sink. The sequencer includes it in the next block; Ethereum settles it in the next batch.
value0 eth
cost now—
walletnone
to 0x00000000000000000000000000000000005ea1ed value 0 data compute a digest first
Any wallet, exchange withdrawal with data support, hardware signer or script that can send a raw transaction on chain id 4663 can seal. The site is a convenience, not a gatekeeper.
verify
Don't ask us. Ask the chain.
Paste a transaction hash. Your browser fetches it from an RPC node, checks it is addressed to the sink, decodes the payload and compares it with a digest you recompute here. The site never sees the file and never vouches for anything: the node does.
theneth_getBlockByNumber
truststhe node you configure
ledger
What has been written.
Every seal addressed to the sink, newest first, read from the public explorer index and decoded here. Records that do not parse as STRATA payloads are shown but flagged. Click any row to verify it in layer.04.
sourceexplorer
refresh30 s
pulse
The substrate, live.
Block by block from the RPC node. The rate the sequencer emits at, the Ethereum block each Robinhood block references, the gas actually spent. Nothing here is cached by us; close the tab and it is gone.
spec
Thirty-eight bytes, specified.
The whole protocol fits on one screen. Anyone can implement a writer or a reader from this alone. The documentation covers the rest: threat model, manifests, fees, roadmap.
STRATA/1 payload — 38 bytes, sent as calldata to the sink
offset len field value
0x00 4 magic 53 54 52 41 "STRA"
0x04 1 version 01
0x05 1 kind 00 = keccak-256 of bytes
01 = sorted-pair merkle root of keccak-256 leaves
0x06 32 digest the 32-byte commitment
envelope
to 0x00000000000000000000000000000000005ea1ed (the sink; no code, no key)
value 0
chain 4663 (Robinhood Chain mainnet)
semantics
a record proves that digest was known to from no later than the block's timestamp.
it proves nothing about authorship, content, or exclusivity. see docs → threat model.
// the exact function this page uses
function encodePayload(kind, digestHex) {
return '0x' + '53545241' + '01' + kind + digestHex.replace(/^0x/, '');
}
// single digest
const digest = keccak256(fileBytes); // js-sha3, hex without 0x
const data = encodePayload('00', digest);
// merkle root over several files (sorted-pair, odd leaf promoted)
const leaves = files.map(f => keccak256(f));
let level = leaves;
while (level.length > 1) {
const next = [];
for (let i = 0; i < level.length; i += 2) {
if (i + 1 === level.length) { next.push(level[i]); continue; }
const [lo, hi] = level[i] < level[i+1] ? [level[i], level[i+1]] : [level[i+1], level[i]];
next.push(keccak256(hexToBytes(lo + hi)));
}
level = next;
}
const root = level[0];
const data = encodePayload('01', root);
// send (EIP-1193)
await ethereum.request({ method: 'eth_sendTransaction',
params: [{ from, to: '0x00000000000000000000000000000000005ea1ed', value: '0x0', data }] });
# 1. fetch the transaction from any Robinhood Chain node
curl -s https://rpc.mainnet.chain.robinhood.com \
-H 'content-type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionByHash","params":["0xTX"]}'
# 2. check .result.to == 0x…5ea1ed and .result.input begins with 0x5354524101
# 3. the last 64 hex chars of .result.input are the sealed digest
# 4. recompute the digest of your file (any keccak-256 tool)
cast keccak "$(cat file.bin | xxd -p | tr -d '\n')" # foundry
python3 -c "import sys,sha3;print(sha3.keccak_256(open(sys.argv[1],'rb').read()).hexdigest())" file.bin
# 5. read the block for the timestamp and the L1 reference
curl -s https://rpc.mainnet.chain.robinhood.com \
-H 'content-type: application/json' \
-d '{"jsonrpc":"2.0","id":2,"method":"eth_getBlockByNumber","params":["0xBLOCK",false]}'
# .result.timestamp (unix, hex) · .result.l1BlockNumber (the Ethereum block it references)
// Optional. STRATA/1 needs no contract; this is the v2 registry from the roadmap.
// It adds on-chain lookups (sealedAt) and events for log-based indexing.
// Source: contracts/StrataRegistry.sol
contract StrataRegistry {
event Sealed(bytes32 indexed digest, uint8 kind, address indexed by, uint64 at);
mapping(bytes32 => uint64) public sealedAt;
function seal(bytes32 digest, uint8 kind) external {
if (sealedAt[digest] == 0) sealedAt[digest] = uint64(block.timestamp);
emit Sealed(digest, kind, msg.sender, uint64(block.timestamp));
}
}