What is Integra?

Integra is a blockchain protocol for on-chain record identity. It lets you register content hashes, establish ownership, manage access control, and tokenize real-world agreements -- all through immutable smart contracts deployed on EVM chains.

The Problem

Traditional agreements and records exist as static files. Once signed, they sit in filing cabinets, email inboxes, or cloud storage with no standard way to:

• Prove existence -- Was this version of the document the one that was actually signed? When was it created?
• Verify integrity -- Has anyone altered the content since it was executed?
• Establish ownership -- Who controls this agreement? Can that be proven cryptographically?
• Enable programmability -- Can the agreement trigger payments, enforce conditions, or interact with other contracts?
• Achieve interoperability -- Can different systems, organizations, and chains reference the same agreement in a standard way?

The Solution

Integra addresses these gaps through a layered smart contract protocol:

Content hash registration via IntegraExistenceV1 -- a minimal, write-once, permissionless contract. Any address can register a bytes32 content hash. Once registered, it cannot be re-registered or modified. First registration wins. This provides a permanent, tamper-proof existence proof.

Record management via IntegraRecordV1 -- the central contract of the protocol. It binds a content hash to an owner, associates tokenizers and resolvers, authorizes executors for gasless workflows, and manages metadata. Each record is identified by a globally unique integraHash.

Attestation-gated access control -- a 256-bit capability bitmask system verified through EAS (Ethereum Attestation Service) attestations. Permissions are cryptographically signed, timestamped, and revocable. Fine-grained: a party can be granted "sign and view" without "amend."

Tokenization -- 23 tokenizer contracts spanning ERC-20, ERC-721, and ERC-1155 standards. These represent record rights, ownership shares, membership, licenses, governance votes, rental access, and more.

How It Works

Every record in Integra starts with a content hash -- a bytes32 value derived from the content of the file, agreement, or artifact being registered.

// 1. Compute the content hash off-chain
bytes32 contentHash = keccak256(abi.encodePacked(fileContent));

// 2. Register existence (permissionless, write-once)
IntegraExistenceV1 existence = IntegraExistenceV1(EXISTENCE_ADDRESS);
uint64 timestamp = existence.register(contentHash);

// 3. Check existence at any time
bool isRegistered = existence.exists(contentHash);

Once the content hash exists on-chain, you can create a full record with ownership, tokenizer association, and resolver bindings:

// Create a record with ownership and tokenization
IntegraRecordV1 record = IntegraRecordV1(RECORD_ADDRESS);
bytes32 integraHash = record.register(
    RegistrationParams({
        integraHash: computedIntegraHash,
        contentHash: contentHash,
        identityExtension: identityExt,
        referenceHash: bytes32(0),
        tokenizer: tokenizerAddress,
        resolverIds: resolverIds,
        executor: executorAddress
    }),
    proofData
);

The integraHash is the primary key for all subsequent operations -- token reservation, claim, transfer, resolver queries, and messaging.

Architecture at a Glance

The protocol is organized into 11 layers, each with a single responsibility. Lower layers never import upper layers. All inter-contract references are immutable -- set at deployment, never changeable.

No contracts use proxy patterns or upgradeability. Every contract is deployed once and is immutable. Governance evolves through progressive ossification: BOOTSTRAP to MULTISIG to DAO to OSSIFIED.

For the full architecture breakdown, see Architecture.

Key Concepts

Before diving deeper, here are the terms you will encounter throughout the documentation:

• Content hash -- A bytes32 value representing the hash of a file or agreement. Registered in IntegraExistenceV1.
• Integra hash -- A globally unique bytes32 identifier for a record in IntegraRecordV1. Derived from the content hash plus additional identity data.
• Record -- The on-chain entity that binds a content hash to an owner, tokenizer, resolvers, and executor.
• Tokenizer -- A smart contract that mints tokens representing rights associated with a record (ownership, shares, licenses, badges, etc.).
• Resolver -- A pluggable on-chain module that attaches logic to a record (compliance checks, dispute resolution, contact metadata).
• Capability -- A single permission bit in a 256-bit bitmask, verified through attestations.
• Executor -- An address authorized by the record owner to perform operations on their behalf (enables gasless workflows).

Next Steps

• Why Real World Contracts? -- The motivation behind bringing agreements on-chain
• Architecture -- Deep dive into the 11-layer system
• Quickstart -- Start building with Integra