FACTA Check

rules.notices

Version
0.1.0
Terms named on this page

A notice records one material event about an agent or a token: an identity changed hands, an agent wallet changed, a registration file changed, an issuer scheduled a new multiplier, an issuer's registry and the chain disagreed, or a token's beacon slot did not hold the Stock Token beacon. Each notice is one sentence from a fixed template, with the reads that show the event. No model writes a notice. Nobody can buy, delay, edit or remove one.

Changelog

Changelog
VersionDateWhat changed
0.1.0
2026-11-11
First version: five kinds of change, and corrections.

What this method records, and what it does not

It records:

  • a change of an identity's owner, of its agent wallet, and of its registration URI or file, found by comparing two reads of the same value;
  • a multiplier change that an issuer has scheduled for a token it lists;
  • a disagreement between an issuer's registry and the chain about a token, and a Robinhood token whose beacon slot does not hold the Stock Token beacon;
  • a correction of an earlier notice that was wrong.

It does not:

  • record every event on the chain. This version reads no long log ranges, so it finds a change by comparing a stored read with a new one. A value that changes and changes back between two reads leaves no notice.
  • say when an event happened. It gives a window: from the last read known to have returned the old value to the first read that showed the new one. The event happened somewhere inside that window, which can be much more than a day wide.
  • judge an event. A transfer is reported as a transfer. A notice carries no term of the vocabulary, no opinion and no advice.
  • record a first sighting. The first full read of the registry finds every identity for the first time, and that is not a change.
  • record a registration file that stops answering. A 404, a 410, a refusal or a third failed attempt in a row is not a change of the file: register.file gives the identity the term Unreachable, which its page shows, and no notice is written.
  • record a changed incomeWriter value or a changed StablePair reference rate in this version. Both are stored on their record with the block they were read at.
  • cover the kinds that come from other methods' reads: a changed creator fee recipient and a pending takeover on Pons, a changed opinion, a broken pledge and a changed status. This version records none of them.

The kinds

Every notice is filed under one subject: agent:<id> for the three identity kinds, token:<address> for the two market kinds. A correction is filed under the subject of the notice it corrects, so one query finds a subject's notices and their corrections together.

Each kind's sentence is given below as its template: the words every notice of that case prints, with each value in angle brackets. A notice puts its own values in their place and changes nothing else. In a change, <since> and <time> bound its window: <since> is a time, or block and a block number, and <time> is when the new value was first read (see "Block time or first observed"). In a state, <time> is when it was first observed. A time is given to the minute, in UTC. An address or a hash is shortened in the middle, and the notice's payload holds it in full.

identity_transferred

  • Source: the job register.crawl, the full read of the Identity Registry. It reads ownerOf for every identity once in each pass and compares each owner with the stored one. The method page register.identity gives the length of a pass.
  • Fires when: the owner differs, and a second read of ownerOf at the same block, from an endpoint run by another operator, shows the same new owner.
  • Payload: agentId, from, to.
  • Time: first observed. since is the last read known to have returned the old owner: see "Block time or first observed".
  • Evidence: the ownerOf call that returned the old owner and the one that returned the new owner, each with its block.
  • Read twice: yes.

When the last completed pass recorded its read of the identity, the window starts at the time of that read. Otherwise it starts at the block the stored owner was written at, however long ago that was, and <since> is that block:

Agent <id>: identity transferred from <old owner> to <new owner> between <since> and <time>. Seen by comparing two reads.

The Identity Registry clears an identity's agent wallet when the identity is transferred. A transfer of an identity whose wallet was set therefore usually comes with an agent_wallet_changed notice that says the wallet was cleared.

agent_wallet_changed

  • Source: the job register.crawl, which reads getAgentWallet for every identity once in each pass of the full read.
  • Fires when: the wallet differs from the one stored, and a second read at the same block, from an endpoint run by another operator, shows the same new value.
  • Payload: agentId, from (null when none was set), to (null when it was cleared).
  • Time: first observed. since is the last read known to have returned the old wallet, as for a transfer.
  • Evidence: the getAgentWallet call that returned the old value and the one that returned the new value, each with its block.
  • Read twice: yes.

One wallet replaced by another:

Agent <id>: agent wallet changed from <old wallet> to <new wallet> between <since> and <time>. Seen by comparing two reads.

A wallet set where none was set:

Agent <id>: agent wallet set to <new wallet> between <since> and <time>. None was set before. Seen by comparing two reads.

A wallet cleared:

Agent <id>: agent wallet <old wallet> cleared between <since> and <time>. Seen by comparing two reads.

registration_file_changed

  • Sources: two jobs.
    • register.crawl: reads tokenURI once in each pass of the full read. When the URI differs from the stored one, uriChanged is true, and since is the last read known to have returned the old URI, as for a transfer.
    • register.file-fetch: reads each registration file about once a week. When the SHA-256 of what the same URI returns differs from the stored hash, uriChanged is false, and since is the time of the last fetch that returned the old hash. A fetch that failed, timed out or was refused dates nothing. When no such time is stored, the row is updated and no notice is written. A first read of a file is not a change.
    • A file the batch runner read and uploaded to the server goes through the same comparison, with the same rules.
  • Payload: agentId, fromHash, toHash, uriChanged.
    • With uriChanged: true both hashes are null. When the notice is written, the file behind the new URI has not been read, so the sentence says only that the URI changed. null never means that the new URI has no file.
    • With uriChanged: false the two hashes are the SHA-256 of what two fetches of the same URI returned: the fetch that returned the old hash, and the fetch that showed the new one. Neither is null. A body that is not a registration file has a hash too, so a change from a valid file to such a body is a notice, and so is the change from that body to the next valid file. A fetch that returned no body is never a side of a change.
  • Time: first observed. since is the last read known to have returned the old URI or the old hash, by source above.
  • Evidence: for a new URI, the tokenURI call that returned the old URI and the one that returned the new URI, each with its block; for a new file, the fetch that returned the old hash, which is the read since names, and the fetch that showed the change, each with its URL, its time and the SHA-256 of what came back.
  • Read twice: no for a new file under the same URI (uriChanged: false): its hash is taken from bytes FACTA fetched itself. Yes for a new URI (uriChanged: true): tokenURI is read again at the same block, from an endpoint run by another operator, and neither the row nor the notice is written until both reads show the same URI.

The same URI with a new file:

Agent <id>: registration file changed between <since> and <time>. File hash before: <old hash>; after: <new hash>. Seen by comparing two reads.

A new URI. The sentence gives no hash, because the file behind the new URI has not been read yet:

Agent <id>: registration URI changed between <since> and <time>. Seen by comparing two reads.

multiplier_scheduled

  • Source: the job master.registry-sync, whose on-chain cross-check reads each listed token's uiMultiplier(), newUIMultiplier() and effectiveAt() every 6 hours, beside the pending multiplier in the issuer's registry. The method page master.multiplier gives the details.
  • Fires when: a pending multiplier is seen on chain, and a second read of the same three calls shows the same schedule (below). It is a state, not a change: one notice is recorded for one set of values, which are the token, its symbol, the current value, the pending value and the effective time. A new value or a new time is a new notice. The same values seen again are not, even when the schedule ended in between (see "Limits").
  • Payload: token, symbol, current, pending, effectiveAt.
  • Time: first observed. A state has no since.
  • Evidence: the processed registry response every stored row was written from (URL, the time it was first fetched, SHA-256), which states the token's symbol, and the calls uiMultiplier(), newUIMultiplier() and effectiveAt() at one block, which give the current value, the pending value and its effective time. Between the two it cites the step's own fetch of the registry, as a disagreement does.
  • Read twice: yes. uiMultiplier(), newUIMultiplier() and effectiveAt() are read again at the same block, from an endpoint run by another operator, before the notice is written. When that read fails or shows anything else, no notice is written, and the next run reads the token again. The schedule is read from the token's contract, and the issuer's registry need not state it, so one endpoint's answer would otherwise be all the notice rests on.

<symbol> is the symbol the issuer lists for the token, <address> is the token's address, and <current> and <pending> are the current and the scheduled shares per token, never rounded:

Token "<symbol>" (<address>): multiplier change scheduled, from <current> to <pending> shares per token, effective <effective time>. First observed at <time>.

registry_chain_mismatch

  • Sources: two jobs, every 6 hours.
    • master.registry-sync compares what the issuer's registry states about each Robinhood token with what the token's contract answers: the identifier (uid), the current multiplier (multiplier), and the pending multiplier with its effective time (pendingMultiplier). It also compares the address in the token's beacon slot with the Stock Token beacon (beacon), which the registry does not state. The method page master.multiplier gives the details.
    • master.ondo-sync compares each Ondo token's symbol() with its symbol in the reviewed copy of Ondo's token file (symbol), by their comparison key. The method page master.listing gives the details.
  • Fires when: a field disagrees, and the issuer's own statement cannot explain what the chain shows (below); a second read of the chain value at the same block, from an endpoint run by another operator, shows the same value; and the values the notice would quote are those of the fetch it would cite (below). It is a state: one notice is recorded for one set of values.
  • Payload: token, symbol, field, registry, chain. symbol is the symbol the issuer lists for the token, from the fetch the notice cites. registry and chain are the two sides, as text.
    • A side that returned no value holds one of four fixed words. They are FACTA's own words, so a sentence prints them as they are and never as a quotation: none when the side states no such value, reverted when the call reverted or halted, no data when the call succeeded and returned no data, as an address with no code does, and unreadable answer when the answer could not be decoded as the value asked for.
    • For symbol, registry is the symbol in the reviewed copy of Ondo's token file, and chain is the symbol the token's symbol() returned, cleaned of invisible characters and cut to 32 characters before it is stored. Each is a subject's own word, so the sentence shows both as quotations.
    • For pendingMultiplier, each side is a value and its effective time, and the chain's side is none when uiMultiplier() and newUIMultiplier() answer the same value.
    • For beacon, registry is the Stock Token beacon the slot was compared with, which is not a value the registry states, and chain is the address in the slot.
  • Time: first observed.
  • Evidence: by source.
    • master.registry-sync: the processed registry response every stored row was written from (URL, the time it was first fetched, SHA-256), which states the token's symbol and, for every field but beacon, the registry's side; the step's own fetch of the registry, made before its chain read, which answered that response again (URL, the time of that fetch, the same SHA-256; for an answer 304, the SHA-256 of the body whose ETag it confirmed); then every chain read the chain's side comes from, all at one block. That is uid() for uid; uiMultiplier() for multiplier; uiMultiplier(), newUIMultiplier() and effectiveAt() for pendingMultiplier, whose chain side quotes a value and its time; and the storage slot for beacon. The second reading reads the same calls, or the same slot, at the same block.
    • master.ondo-sync: the reviewed file, with its source and review date; the fetch of Ondo's live file, in the same run, that showed the reviewed file is still Ondo's current file, by URL, time and SHA-256 (for an answer 304, the SHA-256 of the body whose ETag it confirmed); and the symbol() call at its block.
  • Read twice: yes. A beacon slot is read a second time in the same way as a call.

A notice quotes what an issuer states only as the fetch it cites shows it. So a disagreement is held, not published, while the values it would quote are not those of the fetch it would cite:

  • master.registry-sync: a notice on any field but the beacon quotes the value stored for the token as the registry's, and every notice cites the registry fetch the stored rows were written from, and the step's own fetch that answered it again. A new version of the registry is written over several steps, and until its last page is written the stored rows may mix two versions. While that write is unfinished, no cross-check runs: every page of an unfinished write is saved with a mark in the job's state master.registry, so the mark survives a run that fails in the middle of the write, and a cross-check step that finds the mark, or finds no state yet, compares nothing and sends the run back to write every row from one fetch. Every step fetches the registry before it compares, and compares only when its own fetch returned the version the rows were written from. So no comparison rests on a fetch older than its own step, and a run that was paused in the middle of its cross-check fetches again when it resumes: a comparison rests on a fetch made in the same run, never on one a paused run left behind.
  • master.ondo-sync: a notice quotes the reviewed copy of Ondo's token file as Ondo's. It is published only when the same run's fetch of Ondo's live file shows that the reviewed copy is still Ondo's current file: an answer 200 whose body has the reviewed SHA-256, or an answer 304 to the ETag of a body the job hashed to that SHA-256. When the live file differs from the reviewed copy, or the fetch failed, a disagreement the second read confirmed is held: no notice, counted as held in the job's state master.ondo, and the next run reads the symbol, the second endpoint and the live file again.

A schedule taking effect is not a disagreement. A disagreement is one only if the issuer's own statement cannot explain what the chain shows. An issuer's registry can state a pending multiplier and the time it takes effect, and the token's uiMultiplier() switches to that value at that time. So when the chain's multiplier equals the pending value the registry itself states, and it was read at or after that value's effective time, the schedule has taken effect, and no notice is written.

A value the registry states, under uid, multiplier or pendingMultiplier. <field> is the field's name, and a side that returned no value is one of the four fixed words, printed as it is:

Token "<symbol>" (<address>): the issuer's registry and the chain disagreed on <field>. Registry: <registry side>; chain: <chain side>. First observed at <time>.

A symbol. <symbol> is the symbol in the reviewed copy of Ondo's token file, which is also the registry's side, and <chain symbol> is the symbol symbol() returned. Both sides are quotations. When symbol() gave no symbol, the chain's side is one of the fixed words instead, printed as it is:

Token "<symbol>" (<address>): the issuer's registry and the chain disagreed on symbol. Registry: "<symbol>"; chain: "<chain symbol>". First observed at <time>.

The issuer's registry states no beacon. The cross-check expects every Robinhood token the registry lists to be a beacon proxy of one contract, the Stock Token beacon 0xe10b6f6b275de231345c20d14ab812db62151b00, because listed tokens were read on chain pointing to it before master.multiplier was first written. That expectation is FACTA's inference from the chain, not a statement of the issuer. So the cross-check compares the address in each token's EIP-1967 beacon slot with that one address, and a beacon notice says only what the slot holds and what it was compared with. It never names the registry.

The beacon. <slot address> is the address the slot holds:

Token "<symbol>" (<address>): its beacon slot holds <slot address>, not the Stock Token beacon 0xe10b6f…151b00 it was compared with. First observed at <time>.

notice_corrected

  • Source: the ingest endpoint, from a rules.corrections document that the batch runner signed and uploaded.
  • Fires when: an item of that document names a notice on file and gives a reason of 1 to 300 characters that holds no word FACTA never uses about a subject. See "How a wrong notice is corrected".
  • Payload: noticeId, reason.
  • Time: when the server recorded the correction.
  • Evidence: none on the notice. The upload is kept in the server's append-only log, with its signature.

<number> is the number of the notice it corrects, and <reason> is the publisher's one sentence, given a full stop when it has none:

Correction to notice <number>. <reason>

Block time or first observed

Each notice says how its time is known, in timing:

  • observed: the event was found by comparing two reads. occurredAt is when the new value was first read. For a change, the sentence gives the window from since to occurredAt, and never a single moment the event was not seen at.
  • block: the event was read from the chain's own record of it, and occurredAt is the time of its block.

Every notice of version 0.1.0 is observed. A kind read from events would carry its block's time; this version reads none.

For a change, since is the last read known to have returned the old value. It is an L2 block number or a time, and the sentence shows it as one or the other:

  • An owner, an agent wallet or a registration URI: the time at which this identity was read by the last completed pass of the full read, when that pass recorded one; otherwise the block at which the stored value was written. A pass writes only the rows that changed, so that block is the block of the identity's last change or of its first read, and it can be months old.
  • A file: the time of the last fetch that returned the old hash, never the time of a later attempt that failed.

The window is as wide as what was observed, and never narrower. It can be much more than a day for an identity and much more than a week for a file. A pass that runs late, a read that fails, a change the second read does not confirm and a pass that recorded no read of the identity each widen it. The event happened somewhere inside the window, and nothing on this page promises a narrower one.

A state, which is a schedule or a disagreement, has no since. It is dated by when it was first observed.

Read twice before written

Four kinds name a party: identity_transferred and agent_wallet_changed are statements about a named agent, and registry_chain_mismatch and multiplier_scheduled are statements about a named issuer's token. Every notice rests on public endpoints that no one promises to keep correct, and a notice is never removed. So one throttled or wrong answer must not publish that a real agent's wallet changed, or that an issuer scheduled a change.

So before one of these four is written, the value it states (for a beacon, its storage slot; for a schedule, its three calls) is read again at the same block from an endpoint run by a different operator. When that read fails or shows anything else, the step writes neither the row nor the notice for that subject and moves on. The next pass meets it again. It costs one more request, and only in a step that found something to write.

A new registration URI is read twice in the same way, because it decides which file every surface then quotes as the agent's own. So a registration_file_changed notice with uriChanged: true rests on two reads, and one with uriChanged: false rests on the SHA-256 of the file FACTA fetched, a fact about one fetch.

For every kind, a read that failed is never a change. An endpoint that refuses or times out fails the whole read, and the step is tried again. A read that failed is never a side of a notice either: it dates nothing and is evidence of nothing.

Once, and never changed

  • A notice is recorded at most once. Its key is its kind, its subject, its values and its since. A step that runs twice records an event once.
  • The same change happening again later is a new notice, because its since is newer. An owner that goes from A to B, back to A and to B again gives three notices.
  • A state has no since, so its key is its kind, its subject and its values: one notice for one set of values. A state that ends and comes back with the same values is therefore not recorded a second time (see "Limits").
  • A notice is never updated or deleted, by anyone.

How a wrong notice is corrected

  1. Anyone who believes a notice is wrong writes to the contact address on the site, with the evidence. A contact address is published on the site before launch.
  2. The publisher checks the evidence. When the notice was wrong, the publisher runs the batch runner's notice:correct command with the notice's number and one plain sentence that says what was wrong and what is right.
  3. The batch runner signs a rules.corrections document and uploads it. The server checks the signature, then that the notice exists, that the reason holds 1 to 300 characters, and that no word of it is one FACTA never uses about a subject. A reason is FACTA's own published sentence about a subject, so the last check reads every word: the reason is refused when a word holds one of those words alone, with a prefix, with an ending or inside a longer word, in any letter case. A judgement with a prefix or an ending says the same. The list is SUBJECT_NEVER_STEMS in packages/contracts/src/vocabulary.ts. So a reason cannot quote a name or a symbol that holds one of them: it names its subject by number or by address.
  4. The server records a notice_corrected notice under the same subject. The wrong notice stays exactly as it was.
  5. Every surface shows the two together: the wrong notice carries correctedBy, the number of its newest correction, and links to it.

No public request writes a notice. A correction needs the batch runner's secret, which never leaves the server's secret store and the runner's own environment. The same correction uploaded twice is recorded once.

Thresholds

Thresholds
WhatDefault
Identities read for owner, wallet and URI
every identity once in each pass of the full read. The method page register.identity gives the window of a pass: one day at the registry's size on 2026-11-11, and more whole days as the registry grows
Registration files read
every file about once a week (register.file)
Issuer registry and on-chain cross-check
every 6 hours
A read that failed for a passing reason
tried again 6 hours later, up to 3 attempts
A correction's reason
1 to 300 characters, on one line, with no word FACTA never uses about a subject, alone or inside another word
A token's symbol inside a sentence
at most 32 characters, cleaned of invisible characters, in quotation marks
Notices on one page of the feed
25, at most 50
Notices in the answer about one subject
the 10 newest
Evidence items on one notice
at most 20

Terms

A notice outputs no term of the vocabulary. It states an event. The terms of a subject, and their definitions, are on the subject's own page and at /vocabulary.

Evidence

Each kind's evidence is listed with the kind above. A change carries both reads: a read that returned the old value, and the read that first showed the new one. An evidence item names a read that returned the value it is cited for. A fetch that failed, timed out or was refused is never evidence of the old value. A reader can repeat every read from what the evidence names: the contract, the function, the arguments and the block of a call; the contract, the slot and the block of a storage read; the URL, the time and the SHA-256 of a fetch; or the path, the source and the review date of a reviewed file.

Recomputation

Version 0.1.0 has no recomputation script of its own. A notice is re-checked by repeating the reads its evidence names. A read at an old block needs an endpoint that serves past state, and no free endpoint does, so a re-check at the head can show only the value as it is now. The recomputation scripts of Register and Master (packages/register/recompute.ts and packages/master/recompute.ts) re-read the current values of an agent and a token.

Known ways to game this method, and what it does about each

  • Changing a value and changing it back between two reads. The change is never seen, and no notice records it. This method does nothing about it in version 0.1.0 and says so here. Reading the events themselves is left to a later version.
  • Changing a value right after a read, so the notice looks late. The sentence gives a window, from the last read known to have returned the old value to the read that showed the new one, and never a single moment. So a change is never dated to a time it was not seen at.
  • Making a fetch fail after changing a file, so the change looks newer than it is. An operator can see the crawler coming: it names itself in every request. A fetch that failed, timed out or was refused dates nothing and is evidence of nothing. The window starts at the last fetch that returned the old hash, however many attempts failed after it.
  • A public endpoint that answers wrongly, or is made to. The four kinds that name a party, and a new registration URI, are read twice, from endpoints run by different operators, and are written only when both agree. A failed read is never a change.
  • An issuer's list that changes under a comparison, such as a registry, or a cache in front of it, that serves two versions in turn, or an Ondo file corrected after its review. A notice quotes what an issuer states only as the fetch it cites shows it. A disagreement is held, not published, while the values it would quote are not those of that fetch.
  • Flooding the feed with real changes, for example by moving many identities back and forth. Each change seen is a true notice and is recorded. The job runner holds back scheduled work once the day's database writes pass their limit, so a flood delays later notices and cannot break the site. The feed is newest first, and the filter by subject still finds one agent's notices.
  • A registration file that changes on every fetch, for example one that carries the time. Each weekly read records the change it saw. That is what was observed, and the notice says so.
  • A token symbol written to mislead, with invisible characters, a direction override, quotation marks, a vocabulary term, an instruction or a sentence of its own. A notice names a token by its address and by the symbol its issuer lists, never by what the token's own symbol() returns. The one place a sentence shows what symbol() returned is the chain's side of a symbol disagreement. Every symbol in a sentence is cleaned, cut to 32 characters and shown as a quotation. Every quotation mark inside it, of any kind, and every run of them, becomes one apostrophe, so the symbol cannot end its quotation and read as FACTA's words. A character that only resembles a quotation mark, such as a double prime, is shown as it is. A symbol() that answers one of the fixed words is held and never published (see "Limits"). The template around it is fixed.
  • Asking for a notice to be removed, or paying for that. A notice is never removed or edited. No field, request, key, payment or token balance has any path to a notice. A wrong notice gets a public correction beside it, and nothing else.
  • Uploading the same correction again, or a forged one. A correction needs a valid signature, a signed upload works once, and the same correction twice is recorded once.
  • Pressure about the publisher's own agents and tokens. They get the same notices from the same jobs. The jobs are not told which subjects are the publisher's. The label "operated by the publisher of FACTA" is shown on the subject's own page, in the check console's answer, and in every check_agent and check_market answer: as the label over MCP, as the field operatedByPublisher over REST. A notice and a row of a list, such as the notices feed, the list of agents, an owner's other agents or a fee recipient's agents, do not carry it in this version.

Limits

  • Changes are found by comparing reads, so a change and its reversal between two reads are missed.
  • The time of a change is a window, as wide as what was observed. It starts at the last read known to have returned the old value, which can be much more than a day before for an identity, and much more than a week before for a file.
  • A state that ends and comes back with the same values is not recorded a second time. The key of a state holds no since, so a beacon slot that is restored and later holds the same other address again, or a schedule that is cancelled and set again with the same values and the same time, shows as one notice. This method does nothing about it in version 0.1.0 and says so here.
  • A new file under the same URI rests on one fetch: a registration_file_changed notice with uriChanged: false is not read twice, and its hash is of the bytes FACTA fetched. A wrong one is corrected like any other notice.
  • The key of a scheduled multiplier includes the token's symbol, so an issuer that renames a token while a schedule is pending gives a second notice for the same schedule.
  • A token whose symbol() returns one of the four fixed words, in any letter case and with any run of spaces, would read in a sentence as FACTA's own word. So master.ondo-sync holds such a disagreement and writes no notice, and a fixed word in a notice is always FACTA's. A true disagreement of that kind is never published. Any other text symbol() returns is shown as a quotation. Only the issuer of an Ondo token can set what its symbol() returns.
  • Two symbols that differ only in letters that look alike are both printed as they are, and can look the same in the sentence. The payload holds both.
  • A beacon is compared with one fixed address. Were the issuer to move its tokens to another beacon, every listed Robinhood token would get a beacon notice, each saying what its slot holds.
  • A disagreement can wait. None is compared while a new version of the registry is being written, or while the registry answers two versions in turn, and no symbol disagreement of an Ondo token is published while Ondo's live file differs from the reviewed copy or cannot be read, however long the review takes.
  • A notice is only as complete as the jobs that feed it. When a job is behind, the subject's page says its data is stale, and no notice is written for what was not read.
  • Notices of version 0.1.0 cover Robinhood Chain only, the ERC-8004 Identity Registry at 0x8004a169fb4a3325136eb29fa0ceb6d2e539a432, and the tokens Robinhood and Ondo list on it. No other issuer's list is read.

What overlaps elsewhere

  • The chain explorer shows every Transfer and MetadataSet event of the Identity Registry, with exact block times, to anyone who looks up an identity.
  • Public ERC-8004 trackers, such as 8004scan, list identities and some of their history.
  • An issuer publishes its pending multipliers in its own registry, and the token contract holds them.
  • What this method adds is narrower: the changes of one agent or one token gathered in one feed, each with the two reads behind it, read twice where a party is named, and corrected in public.