Technical content

Aligned Engineering Updates - May 19th - 23rd, 2025

Aligned Layer

26 May 2025 — 3 min read

Latest PRs merged

Refactor sdk modules

https://github.com/yetanotherco/aligned_layer/pull/1941

Refactor SDK modules so they have less indirection and are more structured.

Verify aggregated proof on chain

https://github.com/yetanotherco/aligned_layer/pull/1915

It adds missing functions for users to integrate an application with AlignedProofAggregationService. This consists of:

A way for user to verify that their proof has been aggregated on chain: For that the verifyProofInclusion in ProofAggregationService contract was added. Given the proof program id, public inputs and the merkle proof, it constructs the merkle root and returns a boolean indicating if the aggregated proof exists or not.
check_proof_verification: Given a proof, it queries the logs to find the proof, rebuilds the Merkle tree using the blob, and returns the Merkle path and root for the proof. This path is used as input for the verifyProofInclusion function in the contract.
is_proof_verified_on_chain: Similar to what is_proof_verified already does but in this case it calls the verifyProofInclusion in the contract. This is mostly used for simulations and the former should be preferred.

Work in progress

Aggregate proofs in chunks - In review

https://github.com/yetanotherco/aligned_layer/pull/1896

Split the aggregation of proofs in chunks. For this, the aggregation program had to be split in two:

Chunk aggregator: this runs for each one of the chunks (each chunk is configured to have a max size of 512).

Aggregates proofs.
Commits the Merkle root of each chunk as a public input.

Root aggregator:

Takes all the chunks proof along with their corresponding leaves (proofs commitments).
Verifies that each proof originated from the chunk aggregator program.
Verifies that the merkle root from the proof public input matches the merkle root from the provided proof leaves.
Computes the Merkle root of all leaves and commits it as a public input.
Produces the final aggregated proof that is verified on-chain.

Manage subscription to events without panic

https://github.com/yetanotherco/aligned_layer/pull/1729

Previously, the Operator panicked if one connection (either main or fallback) failed.

The previous solution to this #1692 was to iterate infinitely over both connections, this had the "silent failure" problem, as an operator could fail and retry forever without notice to its owner.

Now if one connection fails, the Operator will use the other one, while continuously trying to reconnect to the failed one; and if both connections fail, and the retryables are consumed, the Operator will exit, logging the errors of each connection RPC, so the owner/manager of the Operator server can fix it accordingly.

This PR also added the usage of fallback when operator calls DisableVerifiers.

Full example and docs for Aggregation Mode

https://github.com/yetanotherco/aligned_layer/pull/1942

It adds full example for aggregation mode. It consists of a very minimal L2 that only holds a commitment of the DB and performs transitions if the proofs has been aggregated and verified on Aligned.

Support search for Aggregation Mode

https://github.com/yetanotherco/aligned_layer/pull/1944

It extends the explorer's search functionality to support querying aggregated proofs by:

Merkle root of the aggregated proof.
Proof commitment included in an aggregated proof.

Note:

Multiple aggregated proofs may share the same Merkle root.
A single proof commitment can be included in multiple aggregated proofs.

In both cases, the search will redirect to the most recent matching aggregated proof.

Targets to verify aggregated proof for every network

https://github.com/yetanotherco/aligned_layer/pull/1943

Previously, the target to verify if a proof was aggregated was hardcoded for holesky-stage. Since we now have ethereum-package and holesky, the target was updated to support every network. Also, based on the NETWORK param the RPC_URL and BEACON_URL are automatically set to public nodes.