Blockchain Anchoring

Why Blockchain

The hash chain (Layer 1) detects tampering — but only if you trust that the hashes themselves haven’t been rewritten. Blockchain anchoring removes that trust requirement. By publishing Merkle roots to a public blockchain, we create a permanent, independently verifiable record that exists outside our control. Even if we rewrote our entire database and recomputed every hash, the on-chain Merkle roots would not match.

How It Works

Collect events

Immutable groups all events created within an anchoring period (daily by default) for each workspace.

Build Merkle tree

A binary Merkle tree is constructed from the event hashes. If the number of leaves is odd, the last leaf is duplicated. The tree is reduced to a single 64-character hex root.

Submit to Base

The Merkle root is submitted to the ImmutableAnchor smart contract on the Base blockchain (Chain ID 8453) — an Ethereum L2.

Confirm on-chain

Once the transaction is confirmed, the anchor record is updated with the transaction hash, block number, and explorer URL.

Events in period          Merkle Tree              On-chain
┌────┐ ┌────┐ ┌────┐
│ h1 │ │ h2 │ │ h3 │     h12 = SHA256(h1+h2)     ┌──────────────┐
└────┘ └────┘ └────┘     h33 = SHA256(h3+h3)     │ ImmutableAnchor │
                          root = SHA256(h12+h33)   │ anchor(root)    │
                                                   │ tx: 0xabc...   │
                                                   └──────────────┘

The Merkle tree is a standard binary tree. When the number of leaves is odd, the last leaf is duplicated to complete the pair. This produces a single 64-character hex root that represents all events in the period.

The Smart Contract

The ImmutableAnchor.sol contract is deliberately simple — its only job is to permanently record Merkle roots:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract ImmutableAnchor {
    event Anchored(bytes32 indexed merkleRoot, uint256 timestamp);

    function anchor(bytes32 merkleRoot) external {
        emit Anchored(merkleRoot, block.timestamp);
    }
}

The Anchored event log is permanent and publicly readable. Anyone can query it from Basescan or directly from a Base node.

Why Base

Base is an Ethereum L2 (Layer 2) rollup. It provides:

Property	Benefit
Low transaction cost	Anchoring costs fractions of a cent per workspace per day
Fast confirmations	Transactions confirm in seconds, not minutes
Ethereum security	Inherits Ethereum’s security guarantees via rollup proofs
Public and permissionless	Anyone can read the chain — no account or API key needed
Chain ID 8453	Standard EVM chain, supported by all major tools

Anchor Lifecycle

Each anchor transitions through three statuses:

pending  →  submitted  →  confirmed

Status	Meaning
`pending`	Merkle root computed, transaction not yet sent
`submitted`	Transaction sent to Base, awaiting confirmation
`confirmed`	Transaction confirmed on-chain, `tx_hash` and `block_number` recorded

Anchor Chaining

Anchors are themselves chained. Each anchor stores a previous_anchor_hash computed from the previous anchor:

previous_anchor_hash = SHA256(previous_merkle_root + previous_tx_hash)

This means deleting or reordering anchors is also detectable. The anchor chain provides a second layer of sequential integrity on top of the event hash chain.

Anchor 1                Anchor 2                Anchor 3
┌────────────────┐      ┌────────────────┐      ┌────────────────┐
│ merkle_root: r1│      │ merkle_root: r2│      │ merkle_root: r3│
│ tx_hash: 0xa.. │      │ tx_hash: 0xb.. │      │ tx_hash: 0xc.. │
│ prev: null     │─────>│ prev: sha(r1+a)│─────>│ prev: sha(r2+b)│
└────────────────┘      └────────────────┘      └────────────────┘

Basescan Verification

Every confirmed anchor includes an explorer_url pointing directly to the transaction on Basescan:

https://basescan.org/tx/{tx_hash}

On Basescan, you can:

Confirm the transaction exists and is confirmed
Read the Anchored event log
Extract the merkleRoot bytes32 value
Compare it to what Immutable reports via the API

This is fully independent verification — no Immutable API involved.

API Access

curl https://getimmutable.dev/api/v1/anchors \
  -H "Authorization: Bearer imk_your_api_key_here"

curl https://getimmutable.dev/api/v1/anchors/anc_abc123/verify \
  -H "Authorization: Bearer imk_your_api_key_here"

const anchors = await client.getAnchors();
const verified = await client.verifyAnchor("anc_abc123");

anchors = client.get_anchors()
verified = client.verify_anchor("anc_abc123")

See the full API reference: List Anchors | Get Anchor | Verify Anchor

Anchors in pending or submitted status cannot be verified on-chain yet. Only confirmed anchors have a tx_hash and block_number. The verify endpoint will return the current status for non-confirmed anchors.

​Why Blockchain

​How It Works

​The Smart Contract

​Why Base

​Anchor Lifecycle

​Anchor Chaining

​Basescan Verification

​API Access

Why Blockchain

How It Works

The Smart Contract

Why Base

Anchor Lifecycle

Anchor Chaining

Basescan Verification

API Access