# Controllers and standards

The controller is the thing the identity is bound to. The standard is the rule for who controls that thing right now.

## The eight standards

The adapter re-reads the controller on every gated call, so control moves the moment the token does - no claim step, no stale owner. Numbering is part of the UBID and never changes.

| Standard | Who controls the identity | delegate.xyz | Notes |
| --- | --- | --- | --- |
| 0ERC721 | whoever ownerOf(tokenId) returns | yes | The token is a sellable asset; the identity travels with it. |
| 1ERC1155 | anyone with balanceOf(account, id) > 0 | no | Every holder is a controller. Mint exactly one of an id for single-holder control. |
| 2ERC6909 | anyone with balanceOf(account, id) > 0 | no | Same rule as ERC1155. |
| 3ERC1155F | whoever ownerOf(tokenId) returns | yes | An ERC-1155 contract that also exposes ownerOf - a single-owner token on a balance standard. |
| 4ERC6909F | whoever ownerOf(tokenId) returns | yes | An ERC-6909 contract that also exposes ownerOf. |
| 5ACCOUNT | the address itself | yes | An EOA, a Safe, or any contract that can make the call as itself. Token id is always 0. |
| 6CONTRACT\_OWNABLE | the contract's current owner() | yes | Follows ownership transfers. The contract itself gets no special access. Token id 0. |
| 7CONTRACT\_ADMIN | holders of DEFAULT\_ADMIN\_ROLE | no | For AccessControl contracts with no owner(). Token id 0. |

## Authorising another wallet

For the standards marked yes, the controller can authorise another address to act for it on [delegate.xyz](https://delegate.xyz), a public registry the adapter reads. A cold wallet or a multisig keeps the token or the contract; a hot wallet manages the identity. The rights key is `keccak256("adapter8004.manage")`, and unscoped delegations count too.

## A contract that speaks more than one standard

Because the standard is in the UBID, an ERC-1155 token can be claimed as ERC1155 (control by balance) or as ERC1155F (control by ownerOf) and get two different identities with two separate reputations. Nothing in the protocol names one canonical. The rule of thumb: pick the standard that describes how the token is actually held. One owner and an ownerOf - use the ownerOf rule. Many holders - use the balance rule.

> The explorer warns before a second identity is created under a different standard for the same coordinates, and shows the siblings on each profile. Continue only if you mean to have two.

## The collection's window

For the ownerOf standards, the token contract itself may act for a token while `ownerOf` reverts or returns zero - before the mint, and again after a burn. That is what lets a collection give every token an identity inside `mint()`:

```solidity
function mint(address to, uint256 tokenId, string calldata agentURI) external {
    ADAPTER.counterfactualRegister(ERC721, address(this), tokenId, agentURI); // still ownerless here
    _safeMint(to, tokenId);                                                     // now the holder controls it
}
```

The same window reopens after a burn. A collection that burns and re-claims is allowed to, and the explorer discloses it: the profile's history shows a collection-authored claim after an owner existed.
