FACTA

register.identity

Version
0.1.0
Terms named on this page

Reads every ERC-8004 identity on Robinhood Chain from the Identity Registry and keeps one file per identity: its owner, its agent wallet, its registration URI, its income writer, when FACTA first read it, and every change since.

Changelog

Changelog
VersionDateChange
0.1.0
2026-11-11
First version.

What it measures

  • Owner: ownerOf(id).
  • Agent wallet: getAgentWallet(id). The registry sets it to the owner at registration, clears it on a transfer, and changes it only with a signature from the new wallet. A zero answer is shown as unset.
  • Registration URI: tokenURI(id), as the chain holds it, after control, format and invisible characters are removed and surrounding spaces trimmed. The URI in the Registered event can be empty, so the method always reads tokenURI. Its scheme is recorded as https, data, ipfs, none when there is no URI, or other: any other scheme, http:// included, or no link at all, such as free text. A URI the method could not read within its limits is recorded as other with the file status invalid (see Thresholds), and only such a URI has that pair: a free-text or non-web URI is other, and register.file records its file as unreachable without requesting it.
  • Income writer: getMetadata(id, "incomeWriter"). Its method page is register.links.
  • First seen: the time FACTA first read the identity.
  • Last change written (lastChangeAt in the API's record): when the full read last wrote a change of the owner, the agent wallet, the URI or the income writer, and null while it has written none since it first read the identity. A new file at the same URI does not move it (register.file records that as a notice of its own), and a correction does not undo it. The "Last change" line the pages show is not this field. It is the newest change notice that no later notice corrects (rules.notices): a change of the owner, the agent wallet, the registration URI or the file at that URI, dated and evidenced by that notice's reads. A changed income writer is no notice in Phase 1: it moves this time, not that line.

"First seen" is not the registration date. It is the day FACTA first read the identity. FACTA does not read the registration events, so it does not know when an identity was registered. An identity that was already there at FACTA's first full read has no first-seen block, and a page says "on file since before" that date. A page never presents first seen as the identity's age.

It does not measure what an agent does, who operates it, or whether its owner and its wallet are the same person.

Inputs

Inputs
InputWhereRead
Identity Registry
0x8004a169fb4a3325136eb29fa0ceb6d2e539a432 on chain 4663
ownerOf, tokenURI, getAgentWallet, getMetadata
Identity count
Storage slot 0xa040f782729de4970518741823ec1276cbcd41a0c7493f62d173341566a04e00 of the registry, while its implementation is 0x7274e874ca62410a93bd8bf61c69d8045e399c02
eth_getStorageAt
Implementation
EIP-1967 implementation slot of the registry
eth_getStorageAt

IDs start at 0 and are issued in sequence; the registry has no totalSupply(). The count sits in a private storage slot of the implementation that was live on 2026-11-10. When the implementation differs, the slot may mean something else, so the count is found by probing ownerOf instead, and the run says so in its log. The probe asks the powers of two, then 256 evenly spaced IDs inside the bracket they leave, until it has asked every ID of the bracket. Each round is one request, and of the IDs that request did not answer with an owner, only the first two above the highest owner are read again alone: about a dozen requests for 26,000 identities, inside one step. The bracket ends at the second ID asked above the highest owner, so an identity with no owner just above the last one, where the probe asks, does not cut the count short.

Two jobs read identities:

  • register.crawl is the full read. A pass reads every identity once, in ID order, from ID 0 to the count read at the start of the pass, 100 identities a step.
  • register.crawl-new runs every hour, whatever the full read is doing: it reads the count, and reads the identities issued since the last run. With no count stored yet it stores the count and reads nothing: the first full read is the crawl's.

Every read of one step is pinned to one block, read once from the head of the chain. All four values of an identity come from one request at that block: the calls of a page travel together, as one call to Multicall3 (0xca11bde05977b3631167028862be2a173976ca11). A call that comes back failed from it is read again alone before it counts as anything, so the evidence of a figure is still the plain call it names.

The full read's window

The full read takes at most 250 steps a day. Its window is the fewest whole days that hold a pass at that rate, counting one step for each page of 100 identities and two more: one that stores the pass's counts and one that closes its window.

The full read's window
Identities in the registryWindow
Up to 24,800
1 day
24,801 to 49,800
2 days
49,801 to 74,800
3 days, and one more day for each further 25,000

The window is decided at the first step of each pass, from the count read then. On 2026-11-11 the registry held 23,397 identities, so the window is one day. The registry does not grow at a steady rate: about 500 identities arrived in ten hours on 2026-11-10 and 36 in the ten hours after. So the method does not plan on a rate; it reads the count at each pass.

A window starts at the start of a UTC day. A pass reads as fast as the day's 250 steps allow, stores its counts, and then waits for its window to end; the next pass starts then. When the day's steps run out, a pass goes on the next day from where it stopped; it is not started over. A pass that runs late, because steps failed or because a day's database writes ran short, finishes late, and the next starts after it. Only a pass whose step fails five times in a row is given up; the next pass then starts from ID 0, at the latest the next day.

Why 250: every job shares one lane of 1,440 steps a day, and the full read's share was planned at 229 steps when the registry held 22,844 identities. 250 holds the registry of 2026-11-11 in one day, keeps the lane within 21 steps of that plan, and stays clear of 300 steps a day, past which a job is moved off the shared lane.

When a read fails

A read that failed is never a value, and it is never a step that went well either.

  • A page that no endpoint served, or whose read did not fit the 40 outside requests one step may make, writes nothing and leaves the pass where it was: the step fails, with the reason on the job's record. The same holds for the head block and for the identity count at the start of a pass.
  • A call that comes back failed from the page's one request is read again alone, one request each. When those reads would not leave the step five requests for what follows the page, the page is cut to its first identities, as many as fit and at least one, with no request spent on the cut, and only they are read to the end. A range whose every call reverts, such as identities that no longer exist, is read a few identities a step; each is found to have no owner, nothing is written for it, and the pass goes on. The cut is not kept: the next step asks for a whole page again.
  • A failed step is tried again after 1, 2, 4, 8 and 16 minutes. After five failures in a row the pass is given up and its record says why; the next pass starts from ID 0, at the latest the next day. Nothing a failed step read is kept.
  • A step stops early only with something to return. A page read in part is written in part, and the next step goes on from the first identity not handled. A page whose answer was over the response cap is halved, and the smaller page is read next. Neither is a failure.

How a change is found

The method compares reads. It does not follow events: no free endpoint serves a day of logs.

  1. At each read, the identity's owner, agent wallet, income writer and URI are compared with the values its row holds, exactly, the full URI included. When all four are equal, nothing is written. A URI is compared by its text and by whether it could be read within the limits. Its scheme is FACTA's classification of that text, not a value the agent set: a change in how FACTA classifies a URI is no change of the agent's URI, and never a notice.
  2. When one differs, the row is rewritten and the change is recorded. A written row keeps a SHA-256 of the four values, made only for a row that is written, and a later write of the row applies only while it still holds that hash.
    • A read at a block older than the block the row was written at says nothing about it: an endpoint that lags can answer an older head. Nothing is compared or written for that identity, and the pass gives it no time.
  3. Every changed value is read a second time: a changed owner, agent wallet, registration URI or income writer is read again at the same block, from an endpoint run by a different operator. The row is rewritten, and its notices recorded, only when both readings agree on every value that changed. When the second reading fails or differs, nothing is written for that identity, and the next pass meets it again. A failed read is never a change. A changed URI decides which file every surface then quotes as the agent's own, so it is confirmed as a transfer is.
    • The values the page's batch read are read again together, in one request. A URI that was over the limits at the last read is read alone, and it is read again alone; so is a value whose answer was over the response cap, which is confirmed only when the second endpoint's answer is over the cap too. So one identity's large answer cannot hold back the other changes of its page.
    • It costs one more request in a step that found a change or a new identity, or a few when calls have to be read again alone, and one more for each changed value read alone.
    • The first read of an identity is not a change, and it records no notice. Its owner and agent wallet are read a second time too, at the same block, from an endpoint run by a different operator, in the same request as the page's changes, and the row is written only when both readings agree: a later transfer or change of wallet names them as its "from" side, so that side never rests on one endpoint. When the second reading fails or differs, nothing is written for that identity, and the next pass meets it again. Its URI and income writer at the first read rest on one endpoint. Rows first written before this rule rest on one endpoint for all four.
  4. Each change becomes a notice: identity_transferred for the owner, agent_wallet_changed for the wallet, registration_file_changed (with uriChanged) for the URI. A changed income writer rewrites the row and is not a notice. Each notice carries since and two reads as evidence (see "What since is"). An owner that goes from A to B, back to A and to B again is three notices.
    • The notice of a changed URI says only that the URI changed. It carries no file hash. This method reads no file, so when the notice is written the file behind the new URI has not been read. Its evidence is the two reads of tokenURI. What the new file holds is for register.file to say once it has read it, and the first read of a new URI is not a notice.
  5. A first sighting is not a change. The first full read records no notice.

A changed URI also resets what was learned from the old one: the file's hash, its time and its fields are cleared, the file is read again, and the liveness term is cleared until a job learns the new one, whatever a sweep wrote while this read was under way. A sweep that was still fetching the old URI or asking the old file's services then writes nothing: its write applies only to the row it read (see register.file and register.liveness). The one term this method sets itself is No card, for an identity with no URI (see register.liveness).

A row is rewritten only while it still holds the values it was compared with. Two steps that find the same change write it once.

What since is

A change found by comparing two reads has no moment, only a window: from the last read known to have returned the old value, which is since, to the read that showed the new one. since is always a block, one of two:

  • The block at which this identity was read in the last completed pass, when that pass recorded one and it is later than the block the stored value was written at. A pass that finds an identity unchanged writes nothing to its row. It keeps the time and the block of the read instead (see "How old a value can be"), and that block is what since gives.
  • Otherwise the block at which the stored value was written: the identity's first read, or its last change. This is so when no pass has completed since that write; when the last completed pass gave this identity no read, because its read was not confirmed or was made at an older block; when the value was written by a pass that was then given up, whose reads were not kept; and for a pass stored before its blocks were kept.

A block, never a clock. The time of a step says when FACTA read; the block says where on the chain the value was seen. An endpoint that lags answers an older block than the step's time suggests, so a window dated from the step's time could start after the change it describes. A window that starts at a block cannot.

The window is as wide as what was observed, and no narrower. It is often about a day. After a pass that ran late or was given up it is wider, and for an identity no completed pass has read since its value was written it starts at that write, which can be months earlier. The method does not promise that a change is seen within a day, and no notice assumes it.

The evidence holds the old value at the read since names, with its block, and the new value at the read that showed it, with its block.

How old a value can be

  • A pass reads every identity once, and is planned to take one window. Nothing guarantees that it does. A pass can run late or be given up (see "When a read fails"), and a changed value the second reading does not confirm waits for the next pass. So the time between two reads of an identity is not fixed. No answer and no notice assumes one: each gives the time of the read itself.
  • A new identity is read by register.crawl-new, which runs every hour, whatever the window. A run that fails leaves the new identities to the next.
  • The answer says when this identity was last read. A pass writes only the rows that changed, so it keeps the time and the block of each step and the IDs that step read, and stores that list when the pass ends. An answer's asOf, and its stale entry when there is one, give the time this identity's own page was read in the last completed pass, or the time of its last change or first read when that is later. They never give the time a pass ended or its window started. A notice's since gives the block of that read (see "What since is").
  • While a pass is running, an identity it has already read still shows the time from the pass before. The time shown is always a read that happened; the identity may have been read since.
  • An identity the pass read without confirming its row gets no time from that pass: no identity at that block, an answer that could not be decoded, or a change the second reading did not confirm. Its answer keeps the time of the read that wrote the row.
  • Each figure keeps the block and the time of the read that wrote the row: the first read or the last change. A figure's time can be older than the answer's asOf.
  • After fourteen days without a read of the identity, the answer says it is stale, with the time of the last read, and that no time can be given for the next one. Up to 174,800 identities the window is at most seven days, so only a missed or late pass makes an answer stale. The method will be revised before the registry reaches that size.

Thresholds

Thresholds
ThresholdValueWhy
Identities a step
100, four calls each, 400 calls in one request
One request per page
Response cap
300,000 bytes
A URI is set by a stranger; an answer over the cap is never parsed
Page halving
At most two halvings in one step; the smaller page size is kept for the next step
A pinned read is served only while its block is about ten seconds from the head
Calls read again alone
Each call the page's request answered as failed, one request each, while five requests are left for what follows the page; otherwise the page is cut to as many of its first identities as fit, down to one
A failed call inside the request is decided only by a call of its own
Longest URI kept
16,384 bytes
A longer URI is recorded with the scheme other, the file status invalid and its first 256 characters
Identity over the cap alone
Read without its URI (and without its income writer if still too large)
Recorded with the scheme other and the file status invalid; the crawl goes on
Full read
One pass a window: one day up to 24,800 identities, one more day for each further 25,000
The planned time between two reads of an identity. A pass can run late or be given up; an answer and a notice give the time of the read itself
Steps a day for the full read
250
The shared step lane's share planned for the full read, with room for the growth seen since
New identities
Every hour, 100 a step
Measured on 2026-11-10: about 50 new identities an hour, in bursts
Stale
14 days without a read of the identity
The answer then says so

Terms

This method sets one term of the liveness vocabulary: No card, "the identity has no registration URI". Its definition and the other four terms are on the register.liveness page.

Evidence

Evidence
FigureValueEvidence
owner
Lower-case address
ownerOf(uint256) with the ID, at the block of the read
agent_wallet
Address, or null when unset
getAgentWallet(uint256) with the ID, at that block. An unset wallet has a figure too
registration_uri
The URI as stored
tokenURI(uint256) with the ID, at that block. Absent when the URI was too large to read at all
income_writer
Address, or null
getMetadata(uint256,string) with the ID and incomeWriter, at that block
first_seen
ISO time
ownerOf(uint256) at the first-seen block. For an identity that was there before FACTA looked, at the block of its first read while its row has not changed since; after a change that block is not on file, and no read is cited

The block of a figure is the L2 block number read from the RPC, never one reported by a contract. It is the block of the read that wrote the row: the first read, or the read that found the last change. A pass that finds nothing changed writes nothing, so the stored block can be older than the last pass; the answer's asOf and its stale entries say when the last completed pass read this identity (see "How old a value can be").

Recomputation

pnpm tool packages/register/recompute.ts --envelope <answer.json> --rpc <endpoint>

<answer.json> is the answer of GET /v1/check/agent/{id}, and <endpoint> an https JSON-RPC URL: the script refuses any other and says so. It reads owner, agent_wallet, registration_uri and income_writer again and prints match, mismatch or not re-read for each figure, and exits with 1 when any figure mismatches. No free endpoint serves past state, so it reads at the head and says so: a value that changed since the answer was made shows as a mismatch. With an archive endpoint, --archive reads at the answer's own block. first_seen is FACTA's own observation and is not re-read.

Known ways to game it, and what the method does

Known ways to game it, and what the method does
WayWhat the method does
A URI of tens of kilobytes, or a metadata value of hundreds, to stall the crawl
Every answer is capped. A page over the cap is halved; an identity still over it alone is read without its URI and recorded as invalid. From then on its URI is read alone, at most three such reads a step: it costs one more request a pass, and a page that holds more than three is finished by the following steps. The crawl never stops at it
Many identities with a URI over the limit, so that every pass needs more steps than its window plans
Each costs up to a third of a step on every pass, against a hundredth for any other identity: in a test, a second pass over 1,000 identities took 11 steps with none of them, 21 with 60 and 101 with 300. The window is sized from the count of identities and does not count them, so such a pass ends late, and that is all it does. The full read takes at most 250 steps a day whatever a pass needs, so no other job loses a step. A pass that does not fit its day goes on the next day from where it stopped, and the next pass starts after it. No identity is skipped. And no answer or notice assumes a window: each gives the time of its own identity's read
Control or direction-override characters in the URI, to show one address and fetch another
They are removed before the URI is stored, shown or fetched
A transfer and a transfer back between two reads of the identity
Not seen: the method compares reads, not events. Stated under Limits
A lying endpoint that reports a false owner, wallet, URI or income writer
A change is written only when a second endpoint run by another operator reads the same value at the same block, and so is the first owner and wallet of an identity first read since this rule: for it, a transfer's "from" side is never one endpoint's word. The evidence names the call and the block, so anyone can read it again
An endpoint that lags, or is stuck on an old head, so that old values look current
A read at a block older than the row's own changes nothing and gives the identity no time, and a change is dated from the block that was read, never from the step's clock
A lying endpoint that answers one identity's URI with more than the response cap, to make its file unreadable
The URI is recorded as unreadable only when the second endpoint's answer for that URI alone is over the cap too
A range of identities whose every call reverts, so that the calls read again alone take more requests than a step has
The page is cut until those reads fit the step, at no request: the range is read a few identities a step, and the crawl goes on past it. In a test, a range of 100 such identities took 13 steps, eight identities a step, each within its 40 requests
An upgrade of the registry, so that the count is probed and every ID past it costs a request
One request a round for the probe, and only two IDs of each round read again alone: about a dozen requests for 26,000 identities, where reading every failed one alone took 127
Many identities registered to slow the crawl, or to crowd out other work
The full read takes at most 250 steps a day whatever the registry holds: its window grows by whole days instead, and every answer says when its identity was read. New identities are still read every hour, 100 a request

Limits

  • Changes that happen and reverse between two reads are not seen. The registry's events would show them; reading a day of events is not possible on a free endpoint. Two reads of an identity are usually one window apart, and further apart when a pass ran late or was given up.
  • A change is dated to a window, never to a moment: the method does not know when between two reads it happened. since is the start of that window, and it is a read, not an estimate.
  • The window of a pass is sized from the number of identities alone. An identity whose URI is over the limit costs more steps than that plan counts, so a registry that holds many of them is read more slowly than the table of windows says.
  • The stored block of an unchanged identity is the block of its last change, not of the last pass.
  • The time of an identity's last read comes from the last completed pass. A pass that is still running, or one that failed, adds no time.
  • An identity whose value could not be read (a reverted call that should not revert) is skipped for that pass, logged, and read again at the next.
  • No linked token is shown on an identity in Phase 1 (see register.links).

What exists elsewhere

The registry is public: any ERC-8004 explorer lists identities and their owners. Toll's agent census (https://t0ll.xyz/agents/census), a provider-run ERC-8004 explorer, and 8004scan (https://8004scan.io) each count this chain's identities. On 2026-11-10 the registry's counter read 22,843 a few minutes before 10:38 UTC and 22,844 at 10:38 UTC; Toll's census showed 22,843 at 10:16 UTC and the explorer 22,843, while 8004scan indexed 22,547. A total depends on when it was read: the counter read 23,361 at about 20:50 UTC the same day, and 23,397 at 06:28 UTC on 2026-11-11. What this method adds is the file kept per identity, with every change recorded and its evidence attached.