ERC-8320 Regulated asset claims registry (Regulated Asset Claim)
Draft · Vaults & DeFi · created 2026-07-03
A registry standard for registering an onchain asset's identity, valuation, investment mandate, and compliance status as signed, versioned claims, which validators and activators approve for publication.
Why it is needed
For assets and capital in a market to find and evaluate each other, core facts such as what an asset is, what it is worth, and where a fund will allocate must exist in a machine-readable, verifiable form. Today, however, this information is scattered across offchain materials such as PDFs or emails, requiring manual checking every time and repeated rework for every integration. Standards such as ERC-4626, ERC-7575, and ERC-7540 define how value is held, divided, and settled, and ERC-7943 and ERC-3643 define how regulated assets are transferred and who may hold them, but all of these address how an asset behaves, not what the asset is, what it is worth, or what a fund intends. Without this standard, every issuer, manager, and tokenization platform discloses information in its own way, resulting in repeated, isolated integrations.
What to implement
function grantRoleToClaimType(bytes32 assetId, ClaimType t, RoleKind kind, address who) external;: The registry administrator grants one of the AUTHOR, VALIDATOR, or ACTIVATOR roles for a given asset and claim type.function revokeRoleToClaimType(bytes32 assetId, ClaimType t, RoleKind kind, address who) external;: Revokes a granted role.function isAuthorized(bytes32 assetId, ClaimType t, RoleKind kind, address who) external view returns (bool);: Checks whether a given address holds the specified role for that asset and claim type.function proposeClaim(RegulatedAssetClaim calldata claim, uint256 nonce, uint64 deadline, bytes calldata signature) external;: The author submits a newly signed claim in PROPOSED status.function validateClaim(bytes32 assetId, ClaimType t, uint64 version, address signer, uint256 nonce, uint64 deadline, bytes calldata signature) external;: The validator signs to transition a PROPOSED claim to VALID.function activateClaim(bytes32 assetId, ClaimType t, uint64 version, address signer, uint256 nonce, uint64 deadline, bytes calldata signature) external;: The activator signs to transition a VALID claim to ACTIVE.function suspendClaim(bytes32 assetId, ClaimType t, uint64 version, address signer, uint256 nonce, uint64 deadline, bytes calldata signature) external;: The activator signs to revert an ACTIVE claim back to VALID.function revokeClaim(bytes32 assetId, ClaimType t, uint64 version, address signer, uint256 nonce, uint64 deadline, bytes calldata signature) external;: The validator signs to retire a claim to REVOKED status.function getActiveClaims(bytes32 assetId, ClaimType t) external view returns (RegulatedAssetClaim[] memory activeClaims);: Returns the claims that are currently ACTIVE and within their validity period for a given asset and claim type.function getClaim(bytes32 assetId, ClaimType t, uint64 version) external view returns (RegulatedAssetClaim memory);: Looks up a single claim by exact asset, claim type, and version.function nonces(address signer) external view returns (uint256);: Returns the signer's next expected nonce.function registerAsset(address contractAddr, uint256 subAssetId, uint256 chainId) external returns (bytes32 assetId);: The registry administrator registers a new asset reference and generates an assetId.function removeAsset(bytes32 assetId) external;: Marks the asset as inactive while preserving its references and claim history.function isAssetActive(bytes32 assetId) external view returns (bool);: Checks whether the registry accepts new claim changes for the asset.function getAssetId(address contractAddr, uint256 subAssetId, uint256 chainId) external pure returns (bytes32);: Computes the assetId from the asset reference.function getAssetReference(bytes32 assetId) external view returns (address contractAddr, uint256 subAssetId, uint256 chainId);: Resolves the assetId back to the original asset reference (contract address, subAssetId, chainId).function setRegistry(address registry, bool approved) external;: The asset's owner or admin approves or revokes approval for a specific registry.function getRegistries() external view returns (address[] memory);: Returns the list of registries the asset knows about.function isRegistryApproved(address registry) external view returns (bool);: Checks whether the asset has approved a specific registry.event ClaimProposed(bytes32 indexed assetId, ClaimType indexed claimType, uint64 version, address indexed author);: Emitted when a claim is proposed.event ClaimValidated(bytes32 indexed assetId, ClaimType indexed claimType, uint64 version, address indexed validator);: Emitted when a claim is validated and transitions to VALID.event ClaimActivated(bytes32 indexed assetId, ClaimType indexed claimType, uint64 version, address indexed activator);: Emitted when a claim is activated and transitions to ACTIVE.event ClaimSuspended(bytes32 indexed assetId, ClaimType indexed claimType, uint64 version, address indexed activator);: Emitted when an active claim is suspended back to VALID.event ClaimRevoked(bytes32 indexed assetId, ClaimType indexed claimType, uint64 version, address indexed revoker);: Emitted when a claim is revoked.event RoleGrantedToClaimType(bytes32 indexed assetId, ClaimType claimType, RoleKind kind, address indexed who);: Emitted when a role is granted for an asset and claim type.event RoleRevokedFromClaimType(bytes32 indexed assetId, ClaimType claimType, RoleKind kind, address indexed who);: Emitted when a role is revoked.event AssetRegistered(bytes32 indexed assetId, address indexed contractAddr, uint256 subAssetId, uint256 chainId, address indexed registrant);: Emitted when a new asset is registered in the registry.event AssetRemoved(bytes32 indexed assetId, address indexed admin);: Emitted when an asset is deactivated.event RegistrySet(address indexed registry, address indexed asset, bool approved);: Emitted when an asset approves or revokes approval for a specific registry.
In depth
Asset identification and assetId
assetId is computed as keccak256(chainId, contract, subAssetId), distinguishing different sub-assets within a single contract, such as tranches or share classes. registerAsset can only be called by the registry admin, and an assetId that is already registered cannot be registered again. removeAsset deactivates an asset but does not delete its references and claim history, which remain intact. isAssetActive only indicates whether the registry will accept new claims for that asset; the business operational status (launch, suspension, termination, etc.) is contained within the payload defined by the schema.
8 claim types and their owners
There are 8 claim types: IDENTITY (the asset's identity, typically the issuer), VALUATION (valuation, the administrator), MANDATE (investment mandate, the manager), TERMS (subscription, redemption, and fee terms, the manager), COMPLIANCE (holding and trading eligibility, the compliance provider), BACKING (collateral and reserves, the auditor), EVENT (corporate actions, dividends, etc., the issuer or manager), and RISK (risk framework, the risk manager). Each type has its own author, cadence, and questions, and who holds AUTHOR authority for a given type defines that party's actual role (administrator, auditor, etc.). The grant table itself, not a fixed label, is the list of service providers.
Three roles and the maker-checker structure
Roles are granted per (assetId, claimType) and come in three kinds: AUTHOR (propose), VALIDATOR (validate, revoke), and ACTIVATOR (activate, suspend). Only the registry admin can grant or revoke roles via grantRoleToClaimType and revokeRoleToClaimType, and authority for one claim type cannot be used for another. The rule that a proposer cannot also be a validator (maker-checker, four-eyes) is enforced, since validateClaim requires the signer to differ from the author. The signer may be an EOA or a contract implementing ERC-1271 (such as a multisig).
Claim lifecycle states
A claim advances from PROPOSED to VALID to ACTIVE; ACTIVE can be reverted to VALID via suspendClaim, and a claim can be moved to REVOKED from any of PROPOSED, VALID, or ACTIVE via revokeClaim. If validUntil is nonzero and the current time exceeds it, a VALID or ACTIVE claim is automatically treated as EXPIRED without any transaction. That is, a claim is live only when now is greater than or equal to validFrom, and validUntil is 0 or now is less than validUntil. Multiple versions of the same (assetId, claimType) can be ACTIVE simultaneously, and getActiveClaims returns only those that are actually live.
Signatures and the EIP-712 domain
Every state transition function requires a signature over an EIP-712 type hash, verified via ECDSA for EOAs and ERC-1271 for contracts. The domain is fixed with name="RegulatedAssetClaimRegistry", version="1", chainId, and verifyingContract set to the registry address, binding the signature to a specific registry and chain. The signed hash must include a nonce and a deadline, and the call must revert if block.timestamp exceeds the deadline. The signed nonce must equal nonces(signer), and that nonce increments by 1 once the signature is successfully used. targetState is not a caller-supplied input; the implementation must derive it internally from the function that was called.
Payload envelope and content hash
The off-chain payload referenced by uri is the actual content of the claim, such as facts about the asset or fund rules, and contentHash covers the entire file. Every payload must include a common envelope: schemaId, schemaVersion, claimVariant, assetId, claimVersion, attestorProfile, authoredAt, dataAppliesAt, accessClassification (PUBLIC_DISCOVERY, PERMISSIONED_DISCLOSURE, RESTRICTED_EXECUTION, PRIVATE), and data. The envelope's assetId, schemaId, and claimVersion must match the on-chain claim. It is recommended that payloads be stored in a content-addressed system so that the uri remains resolvable for the asset's required retention period.
Discovery and registry approval
Claims are discovered through event history. ClaimProposed and ClaimActivated index assetId and claimType, letting indexers build a market view without calling each contract individually. tags are public labels for filtering only and must not be treated as binding information. If an asset implements IRegistryAnchor, it can manage which registries it approves via setRegistry, getRegistries, and isRegistryApproved, and consumers should only trust claims from registries for which isRegistryApproved returns true. If an asset does not implement this interface, or is off-chain or immutable, registerAsset is merely a declaration that the registry handles that asset, and consumers should rely on claims only if they trust the registry and its admin.
Proposal status
This standard was created on 2026-07-03 and is currently in Draft status. It is an early proposal still undergoing community discussion and revision, and its interfaces or detailed rules may change in the final version.
Things to watch out for
- A claim is not proof of content: A claim guarantees attribution, versioning, authority, and tamper detection, but does not prove that the payload content is factual. Consumers must verify fetched content against contentHash, and must not treat the mere existence of a claim as proof of its content.
- Trust rests with the registry admin and the authority table: Trust in a claim ultimately comes down to trust in the registry admin and the asset's authority grant table. If the asset implements IRegistryAnchor, consumers must also check whether the asset has approved that registry.
- tags are non-binding labels: Since tags are non-binding labels, content must be verified against the hashed content before being trusted.
- URI mutability risk: If the uri is mutable, it may serve different bytes over time, so only contentHash is the authoritative reference.