Infrastructure for real-world coordination.
Infrastructure for real-world coordination.
Subscribe to Orchestra
Subscribe to Orchestra
Share Dialog
Share Dialog
<100 subscribers
<100 subscribers
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.
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.
Orchestra now includes a dedicated anchoring module with support for both outbound and inbound anchors:
You can now anchor any Orchestra block to another chain by submitting a new transaction:
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.
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.
Orchestra now includes a dedicated anchoring module with support for both outbound and inbound anchors:
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.
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.
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.
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:...
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.
{
"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.
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.
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.
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:...
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.
No activity yet