# Trademark

> The public, first-to-file trademark register for AI agents on Robinhood Chain (chain id 4663). An AI agent, or its builder, files its name and a hash of its logo by burning $MARK. The earliest live filing for a name is the original. Later look-alikes get flagged, so AI agents and people can tell the real agent from a copy before they pay it or trust it.

Every filing and renewal burns $MARK. Burned tokens are gone for good.

## Verify a counterpart before you trust it

An agent tells you its name and shows its logo. Hash the logo (see "Logo hashes" below) and ask:

GET https://botmark.xyz/api/check?name=Scout&sha=0x<sha256 of the logo file>&dhash=<16 hex dHash>

`sha` and `dhash` are optional, but checking only the name can't catch a copied logo. Returns JSON:

```json
{
  "verdict": "copycat",
  "summary": "Possible copycat of Scout (Reg. No. 1, filed 2026-11-20).",
  "query": { "name": "Sc0ut", "key": "sc0ut", "sha": null, "dhash": "0f1e2d3c4b5a6979" },
  "filed": null,
  "matches": [
    {
      "mark": { "tokenId": "…", "number": 1, "name": "Scout", "key": "scout", "holder": "0x…", "url": "https://…",
                "logoSha": "0x…", "logoDhash": "0f1e2d3c4b5a6978", "filedAt": 1795000000, "expires": 1826536000, "status": "registered" },
      "reasons": [
        { "code": "confusable", "text": "Reads as \"scout\" with look-alike characters (0/o)" },
        { "code": "similar_logo", "distance": 1, "text": "Logo looks alike: dHash 1 of 64 bits apart" }
      ]
    }
  ],
  "later": [],
  "notes": [],
  "compared": 42
}
```

- `verdict` is `original` (the name is on file and no earlier filing looks like it), `copycat` (it looks like an earlier filing: see `matches`) or `clear` (nothing on file looks like it).
- `filed` is the live mark under that name, if any. Then check that the wallet you deal with is `filed.holder`, or is linked from `filed.url`. The register proves who filed first. It can't prove who is talking to you.
- `later` lists filings made after `filed` that look like it: possible copies of it.
- Reason codes: `same_name`, `confusable`, `edit_distance`, `contains`, `contained`, `same_logo`, `similar_logo`, `logo_mismatch` (the name is on file with a different logo).

Only live marks count: in force, or in their 30-day grace period. Lapsed filings are ignored.

## Look up a mark

GET https://botmark.xyz/api/mark?name=Scout

Returns `{ name, key, valid, available, pricePerYear, mark }`. `mark` is null when the key was never filed, and has a `status` of `registered`, `grace` or `lapsed` otherwise.

GET https://botmark.xyz/api/stats returns tokens burned, % of supply burned, marks and filings so far, and the price per year.

Onchain:

```bash
cast call <register address, published at launch> "markOfKey(string)((uint256,uint256,string,string,bytes32,uint64,string,address,uint256,uint256,uint8))" "Scout" --rpc-url https://rpc.mainnet.chain.robinhood.com
cast call <register address, published at launch> "markOfLogo(bytes32)((uint256,uint256,string,string,bytes32,uint64,string,address,uint256,uint256,uint8))" 0x<sha256> --rpc-url https://rpc.mainnet.chain.robinhood.com
```

The tuple is (tokenId, number, name, key, logoSha, logoDhash, url, holder, filedAt, expires, status). Status: 0 never filed, 1 registered, 2 grace, 3 lapsed. `marks(start, count)` returns up to 200 marks at once, and `totalMarks()` says how many there are.

## How names match

- A name's key is its ASCII letters and digits, lowercased. "Scout-AI", "scout ai" and "SCOUTAI" all have the key `scoutai`. Only one live mark per key: the first filing wins, onchain.
- The checker also folds look-alike characters before comparing: 0→o, 1 and i→l, 2→z, 3→e, 4→a, 5→s, 6 and 8→b, 7→t, 9→g, rn→m, vv→w.
- Then it flags keys within 2 edits (insert, delete, replace, or swap two neighbours). Keys of 3 or 4 characters are flagged at 1 edit. Keys of 1 or 2 characters only on an exact or look-alike match.
- It flags a name that contains another filed name of 5 or more characters, like "ScoutPro" and "Scout".

## Logo hashes

Each mark stores two hashes of its logo. Compute both from the logo file. The image never needs to be uploaded anywhere.

1. `sha`: SHA-256 of the file's exact bytes, as 0x and 64 hex characters. `shasum -a 256 logo.png`. An exact copy of a live mark's logo file can't be filed under another name.
2. `dhash`: a 64-bit difference hash, so re-saved, resized or slightly edited copies still match. Two logos look alike when their dHashes differ in 10 bits or fewer. Compute it exactly like this:
   1. Decode the image to RGBA pixels at its own size (at least 9 x 8).
   2. Flatten transparency onto white, per channel: c = floor((c*a + 255*(255 - a) + 127) / 255).
   3. Brightness per pixel, in integers: L = 299*R + 587*G + 114*B.
   4. Split the image into a grid 9 cells wide and 8 tall. Pixel (x, y) belongs to cell (floor(x*9/width), floor(y*8/height)). Sum L and count pixels per cell.
   5. For each row, top to bottom, and each of its 8 neighbouring pairs, left to right: the bit is 1 when the right cell's average is higher than the left one's (compare sumRight*countLeft > sumLeft*countRight), else 0.
   6. The first bit is the most significant. Write the 64 bits as 16 lowercase hex characters.

The same in Python with Pillow:

```python
from PIL import Image

def mark_dhash(path):
    im = Image.open(path).convert("RGBA")
    w, h = im.size
    px = im.load()
    sums, counts = [0] * 72, [0] * 72
    for y in range(h):
        cy = y * 8 // h
        for x in range(w):
            r, g, b, a = px[x, y]
            if a != 255:
                r, g, b = ((c * a + 255 * (255 - a) + 127) // 255 for c in (r, g, b))
            i = cy * 9 + x * 9 // w
            sums[i] += 299 * r + 587 * g + 114 * b
            counts[i] += 1
    bits = 0
    for y in range(8):
        for x in range(8):
            l = y * 9 + x
            bits = bits << 1 | (sums[l + 1] * counts[l] > sums[l] * counts[l + 1])
    return f"{bits:016x}"
```

The site runs the same code in the browser, from https://botmark.xyz/similar.js (`dhashFromPixels`). Image decoders differ a little, so the same file can land a bit or two apart. That is why matching allows 10.

## File a mark

Filing costs the price per year (25000 $MARK at launch) times the years, 1 to 10. The tokens are burned at once.

```bash
# 1. Price per mark-year, in token units (18 decimals)
cast call <register address, published at launch> "price()(uint256)" --rpc-url https://rpc.mainnet.chain.robinhood.com
# 2. Is the name's key free, and is the logo file free?
cast call <register address, published at launch> "available(string)(bool)" "Scout" --rpc-url https://rpc.mainnet.chain.robinhood.com
cast call <register address, published at launch> "logoAvailable(bytes32)(bool)" 0x<sha256> --rpc-url https://rpc.mainnet.chain.robinhood.com
# 3. Approve price x years
cast send <token address, published at launch> "approve(address,uint256)" <register address, published at launch> <amount> --rpc-url https://rpc.mainnet.chain.robinhood.com
# 4. File: name, logo sha256, logo dHash (as 0x + 16 hex), url, years
cast send <register address, published at launch> "file(string,bytes32,uint64,string,uint256)" "Scout" 0x<sha256> 0x<dhash> "https://scout.example" 1 --rpc-url https://rpc.mainnet.chain.robinhood.com
```

For a name-only mark, pass `0x0000000000000000000000000000000000000000000000000000000000000000` and `0` as the logo hashes. Check your name and logo with /api/check first: the chain blocks only exact copies, and the checker will flag a look-alike filing as a copycat for everyone to see.

Other calls:
- `renew(string name, uint256 years)`: anyone can extend a mark until 30 days after it expires.
- `setUrl(string name, string url)`: the holder changes the link.
- `keyOf(string)`, `valid(string)`, `idOf(string)`, `getMark(uint256 tokenId)`, `markAt(uint256)`, `totalBurned()`, `totalFilings()`.

## Rules

- Names are 1 to 32 printable ASCII characters, except " \ < > &, with no space at either end and at least one letter or digit.
- One live mark per key. The first filing wins. A logo file whose SHA-256 is held by a live mark can't be filed under another key.
- Marks last 1 to 10 years per payment. After expiry there is a 30-day grace period when only renewal is possible and the name and logo stay reserved. Then anyone can file the name again, and the new filing gets a new date.
- The logo hashes are fixed at filing. The holder can change the link.
- Marks are ERC-721 NFTs and can be sold. A sale keeps the name, logo, link and filing date, and emits `Assigned`.
- The register never holds tokens. Every fee goes straight to the dead address. The owner can pause new filings and renewals and set the price, capped at 1,000,000 $MARK per year. Nothing else.

## Contracts

- Chain: Robinhood Chain, chain id 4663, RPC https://rpc.mainnet.chain.robinhood.com
- Register: <register address, published at launch>
- $MARK token: <token address, published at launch>
- Explorer: https://robinhoodchain.blockscout.com

## ERC-8004 agent identity

Trademark Examiner is an ERC-8004 agent. It registers in the ERC-8004 Identity Registry on Robinhood Chain (eip155:4663:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432) at launch.
- Registration file: https://botmark.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://botmark.xyz/sitemap.xml