# Anchoring Proof Across Chains

By [Orchestra](https://paragraph.com/@orchestra) · 2025-07-10

---

**Orchestra now supports verifiable cross-chain anchoring.** You can publish proof of any Orchestra block to another blockchain, and record anchor proofs from other chains back into Orchestra — without needing bridges, asset transfers, or wrapped tokens.

This is a foundational step toward multi-ledger verifiability — not bridging for liquidity, but anchoring for **trust**.

* * *

Context: Why Anchoring Matters
------------------------------

Blockchains are great at tracking state — but they’re not inherently great at coordination across systems.

Whether you're dealing with:

*   Auditability for real-world assets,
    
*   Timestamped proof of publication,
    
*   or multi-chain coordination between institutions,
    

you need a way to **verify that some data appeared on some chain, at some time, in some specific form** — without needing to fully mirror it.

That’s what anchoring solves.

* * *

What We Shipped
---------------

Orchestra now includes a dedicated anchoring module with support for both outbound and inbound anchors:

### 1\. **Publishing Orchestra Proofs**

You can now anchor any Orchestra block to another chain by submitting a new transaction:

    {
      "type": "ANCHOR_BLOCK_EXTERNALLY",
      "target_chain": "ethereum",
      "target_tx_hash": "0x...",
      "block_height": 1080,
      "proof_hash": "sha256:abc123...",
      "metadata": {
        "relay": "0xsigner",
        "timestamp": "2025-07-09T12:34:00Z"
      }
    }
    

This proves that block 1080 existed at that point in time and commits its content hash to another ledger.

Orchestra computes its own canonical proof hashes for each block using a deterministic hash of the event log — so the anchoring payload is verifiable, compact, and independent of third-party tooling.

Run:

    orchestra get-block-proof --height 1080
    

...to retrieve the current Merkle root and canonical anchor hash for that block.

* * *

### 2\. **Recording External Anchors**

You can also register a foreign anchor on Orchestra:

    {
      "type": "RECORD_EXTERNAL_ANCHOR",
      "source_chain": "bitcoin",
      "source_tx_hash": "...",
      "anchor_hash": "sha256:def456...",
      "context": "settlement_proof"
    }
    

This lets you timestamp and cross-reference offchain state or foreign chains in Orchestra’s own ledger, and link it to specific identities, claims, or assets — fully queryable via CLI or RPC.

* * *

What This Enables
-----------------

Anchoring opens up a number of higher-order capabilities:

*   **Multi-ledger audit trails** Institutions can publish on Orchestra while committing hashes to a public chain like Ethereum or Filecoin, creating a verifiable audit log that spans environments.
    
*   **Offchain state attestations** Verified documents, external API snapshots, or other systems of record can hash data, anchor it to Orchestra, and register its reference for later verification.
    
*   **Cross-chain coordination without bridges** Rather than move tokens between chains, participants can independently publish and verify anchors — enabling workflows, credentials, or program execution logic that spans ecosystems.
    

Orchestra doesn't assume trust between systems. It lets you **prove state** between systems — cryptographically and unambiguously.

* * *

Implementation Details
----------------------

Internally, Orchestra now supports:

*   `BlockProof`: canonical per-block hash structures
    
*   `BlockAnchor` and `ExternalAnchor`: new onchain object types
    
*   Anchor namespaces: `anchor_ext:<chain>:<height>` and `ext_anchor:<chain>:<hash>`
    
*   Event emission: `external_anchor_published` and `external_anchor_recorded`
    

Everything is accessible via:

    # Get proof hash for a given block
    orchestra get-block-proof --height 1080
    
    # Submit a proof publication tx
    orchestra anchor-block --chain ethereum --tx 0xabc --height 1080
    
    # Record an external anchor
    orchestra record-external-anchor --chain bitcoin --tx ... --hash sha256:...
    

* * *

Looking Ahead
-------------

This isn’t about bridges. It’s about **cryptographic auditability** across systems — financial, institutional, civic, or otherwise.

Orchestra was built from first principles to support real-world coordination. That includes the real world’s reality: systems will remain fragmented, pluralistic, and domain-specific.

Anchors are how we make those systems **accountable to each other** — without compromise.

—

Orchestra is a modular L1 designed for programmable coordination. Assets, identities, credentials, and programs are native. There are no smart contracts, no rollup dependencies — just explicit state, clear APIs, and verifiable logic.

Now, that logic can be trusted across chains.

---

*Originally published on [Orchestra](https://paragraph.com/@orchestra/anchoring-proof-across-chains)*