For a Cross-Chain Bridge, How Do Latency Requirements Influence Local Verification vs External zk Verification Layers?

Short version: Your latency SLO really shapes how you set up your bridge architecture. If you need something that works in seconds, you’re probably going to use external verification layers or DVNs for that “soft” security and post-settlement stuff. But if you can afford to wait a few minutes, going with local on-chain verification (like light clients or zk light clients) lets you minimize trust as much as possible. The key is figuring out how to smoothly transition between a “fast UX” and “final settlement.” (docs.layerzero.network)

TL;DR (description)

Cross-chain bridges are juggling a tricky balance: on one hand, there's end-to-end latency, and on the other, there's the thoroughness of on-chain verification. In this post, we're going to break down specific latency ranges based on different architectural choices, whether that’s local verification or external zk verification layers. We’ll also share some fresh stats, gas calculations, and some forward-thinking practices for 2026 that you can start implementing right away. Check it out here: (docs.chain.link)

---

Why latency targets are the first decision you must make

Before diving into discussions about “native light clients” or “zk layers,” let’s root our conversation in solid latency budgets that align with your business tiers and the associated risks:

• When it comes to Ethereum L1, you're looking at block times of about 12 seconds. As for economic finality, you can expect it to take around two epochs, which is roughly 12.8 to 15 minutes right now. There’s some exciting research happening around SSF (Single-Slot Finality) that aims to speed this up to just a single slot, but we’re not there yet. So if you’re relying on Ethereum for finality, plan on budgeting around 15 minutes for a solid settlement. (inevitableeth.com)
• On the flip side, Cosmos/CometBFT chains get their finalization done almost instantly at the consensus layer. When you look at IBC packet lifecycles--think sending and getting acknowledgments--these usually clock in around 55 seconds in practice. This timing can vary due to relayer delays and app acknowledgments, not the consensus itself. So, it’s wise to design for both the median and the edge cases. (mdpi.com)
• According to CCIP’s public documentation, the finality of each individual chain can really affect cross-chain latency. For instance, you have Avalanche coming in at under a second, BNB around 5 seconds, and Ethereum hovering around the 15-minute mark. Plus, many L2s fall into the 17-40 minute range when it comes to being tagged as “finalized.” Just a heads-up: your provider’s “execution latency” is largely a matter of waiting for the source chain to be deemed safe. (docs.chain.link)

These facts shape everything that comes next.

---

Two verification patterns, two latency profiles

1) Local verification on the destination chain

What it is:

So, what exactly are we talking about? Well, let’s break it down.

• The destination chain checks the source chain's state using a light client or zk light client. It also verifies membership or non-membership proofs (like ICS‑23) for messages or asset locks. There’s no outside committee you need to trust; instead, the security relies on the consensus of the source chain. (ibc.cosmos.network)

Latency Profile You Should Plan For:

When you're mapping out your latency profile, here are some key points to keep in mind:

• Network Latency: This is all about the time it takes for data to travel from point A to point B. Ideally, aim for below 50 ms for a speedy user experience.
• Server Processing Time: Think of this as the time it takes your servers to actually process a request. Target around 100 ms here to keep things running smoothly.
• Database Access Time: This is the time needed to fetch or store data from your database. For optimal performance, try to keep this under 20 ms.
• Third-Party API Calls: If you rely on other services, these can really slow things down. Aim for less than 200 ms for these calls to minimize lag.
• Client-Side Rendering: Don't forget about what’s happening on the user's device! Keep rendering time below 30 ms for a snappy interface.
• Total Latency Budget: When you add all this up, you should be looking at a total latency budget of around 300 ms. This is a great benchmark to shoot for to ensure a smooth experience for your users.

By keeping these considerations in mind, you'll be better equipped to plan for and manage latency effectively!

• Cosmos↔Cosmos (IBC): When it comes to consensus finality, it’s pretty much instant! However, for practical end-to-end experiences, you’re looking at roughly 20-60 seconds, depending on how often the relayers are working and how they handle acknowledgments. Check it out for more details: (mdpi.com)
• Ethereum→EVM via zk light client: This one’s a bit different--aim for source finality around 12-15 minutes, plus you have to factor in the time for proof generation and verification. In real-world scenarios like the Gnosis OmniBridge after its zk light client upgrade, you’re generally looking at a total of about 20 minutes. Sure, you get way stronger assurances than what you’d get with multisigs, but just keep in mind that it might take a little longer! For more info, head here: (gnosis.io)

Operational Details That Matter Now

When it comes to getting things done efficiently, here are some crucial operational details you should keep in mind:

1. Clear Communication
   Make sure everyone is on the same page. Sending out regular updates can help avoid confusion and keep the team aligned.
2. Effective Workflow
   Establishing a structured workflow can save time and reduce stress. Consider tools like Trello or Asana to keep tasks organized.
3. Data Management
   Keeping track of your data is essential. Set up a reliable system for storing and retrieving information. Cloud services like Google Drive or Dropbox can be super handy.
4. Budget Monitoring
   It’s important to keep an eye on your expenses. Regularly review your budget to ensure you’re staying within your limits. Tools like Mint or QuickBooks can help with this.
5. Feedback Loop
   Encourage feedback from your team. It’s a great way to identify areas for improvement and boost morale. Regular check-ins can create a more open environment for sharing ideas.
6. Training and Development
   Invest in your team’s growth. Offering training sessions or workshops can enhance skills and increase productivity. Plus, it shows that you value their development.
7. Health and Safety
   Never overlook the well-being of your team. Make sure safety protocols are clear and accessible. Regular health checks or mental health days can really make a difference.
8. Technological Tools
   Utilize the latest tech to streamline operations. From CRM systems to project management software, the right tools can make your life a whole lot easier.

By focusing on these operational details, you can create a more productive and harmonious work environment. Always remember, the little things can really add up!

• Gas math has changed a bit. Since May 7, 2025, the Ethereum mainnet has rolled out BLS12‑381 precompiles (thanks, EIP‑2537!), which means that using BLS and BLS-based SNARK verifiers in contracts is now cheaper than BN254 for a lot of pairing checks. The cost for pairing now sits at 37,700 + 32,600×k gas on BLS12‑381 compared to 45,000 + 34,000×k on BN254. So, if you're already working with a verifier or signature scheme on BLS12‑381, it might be a good idea to re-evaluate your cost model. (blog.ethereum.org)
• On another note, calldata just got pricier for transactions that are heavy on data (thanks to EIP‑7623), which is pushing designs towards aggregation and using blobs for data availability. Reposting large proofs as calldata now hits a lot harder than it did before Pectra. (eips.ethereum.org)
• And if you’re planning to bring Cosmos proofs over to the EVM, make sure to factor in ICS‑23 verification logic. It could be worth exploring zkVM approaches (like SP1 templates) to help you compress the verification step for EVM chains. (github.com)

When to Prefer Local Verification:

Local verification can be a game-changer in certain situations. Here are some scenarios where it really shines:

1. Limited Connectivity
   If you're in an area with spotty internet or limited access to cloud services, local verification ensures you can work without a hitch.
2. Data Privacy
   Handling sensitive information? Keeping everything local can help you maintain privacy and comply with regulations. You control the data, and you know exactly where it’s stored.
3. Speed
   Local verification often means faster processing times. You won't have to deal with any lag from sending data back and forth to the cloud - it’s all right there on your device.
4. Resource Constraints
   If you're using a system with limited resources or need to conserve bandwidth, relying on local verification can help keep things running smoothly without overloading your network.
5. Specific Use Cases
   In situations where real-time feedback is crucial, like in automated systems or IoT devices, local verification can provide the quick responses you need without delays.
6. Customization Needs
   When your verification process needs to be tailored to fit your specific requirements, doing it locally gives you the flexibility to adapt and change things as necessary.

Remember, while local verification has its perks, it's essential to weigh these factors against your overall needs and resources!

• When you're shifting important governance or state across different trust domains, it's okay to handle a bit of latency--up to about 20 minutes--to cut down on the need for external trust. Think of it like “final settlement” messages rather than just user experience signals. A great example of this is the Gnosis OmniBridge upgrade, which is currently accepting around 20 minutes for those solid Ethereum-level assurances. Check it out here: (gnosis.io).

---

2) External zk verification layers (and DVN-style stacks)

What It Is:

When we talk about something, we're diving into a topic that has a lot of interesting layers. It's not just surface-level stuff; there's a whole world behind it waiting to be explored!

You might find that it connects to various fields or concepts, which makes it even more intriguing. Here's a quick rundown of the key points:

• Definition: At its core, it's all about understanding what it really means.
• Significance: Why does it matter? Well, it plays a crucial role in numerous areas.
• Applications: You'll see this concept popping up in everyday life, from tech to art and beyond.

In summary, there's definitely more here than meets the eye, and it's worth taking the time to dig a little deeper!

• Off-chain or separate networks handle a bunch of different proofs and block headers, gather up attestations or proofs, and then send a concise result back to the main chain. This covers proof verification layers (like Aligned’s AVS), coprocessors, and modular setups like LayerZero’s DVN model, which can utilize ZK, committees, or middlechains. (blog.alignedlayer.com)

Latency profile you should plan for:

When thinking about latency, it's important to keep a few key aspects in mind. Here’s a breakdown of what you should consider:

1. Network Latency: This is all about the time it takes for data to travel from one point to another on the network. Think of it as the speed limit on the digital highway. Several factors can impact this, like the physical distance between servers and network congestion.
2. Processing Latency: This refers to the time spent processing requests on servers. It includes everything from database queries to application logic. If your application is doing a lot of heavy lifting, this can add up.
3. Database Latency: Often overlooked, this is the time it takes for your database to respond to a query. It’s crucial to optimize your database for quick lookups and efficient querying.
4. Client Latency: Don’t forget about the user side! This is the delay a user experiences while their device processes data. Optimize your front-end code and reduce the size of resources being loaded to help with this.
5. Geographical Latency: If your users are spread across the globe, consider how physical distance affects latency. Content Delivery Networks (CDNs) are great for minimizing this impact by caching content closer to where users are located.

Tips for Managing Latency:

• Measure Regularly: Use tools to monitor latency in real time. This way, you can spot issues before they become a real pain.
• Optimize Your Code: Review your code and look for areas to streamline. Reducing unnecessary processing will help.
• Load Testing: Before going live, put your system through its paces to see how it handles under pressure.
• Choose the Right Hosting: Picking a good hosting provider can make a big difference in latency. Look for one with data centers that are close to your user base.

By keeping these points in mind, you can set realistic expectations for latency and aim for a smooth experience for your users.

• Getting a “soft” confirmation is super quick since operators are checking things off-chain and co-signing. This means the on-chain thing is just one batched attest/proof, which helps sidestep those lengthy multi-block verification queues. For instance, Aligned mentions they’re doing off-chain verification at thousands of proofs each second, and the on-chain batch cost comes down to just tens of thousands of gas per proof even with moderate batch sizes. Check it out here: (alignedlayer.com).
• When it comes to your “time-to-spend” policy, you can get a bit creative with a two-stage approach: first, you can show users “received” once there’s a quorum from the DVN/verification layer, and then switch to “settled” after the source chain hits hard finality or goes through a zk checkpoint. With LayerZero v2’s X-of-Y-of-N DVN setup, you’ve got the flexibility to adjust this balance for each specific route. Dive into the details here: (docs.layerzero.network).

Operational Details That Now Matter:

• Team Collaboration: Keeping everyone on the same page during projects is crucial. Tools like Slack or Microsoft Teams can help streamline communication and ensure prompt updates.
• Workflow Efficiency: Make sure to review your current processes. Sometimes, a small tweak can save a lot of time and effort. Consider adopting a project management tool like Trello or Asana for better task tracking.
• Feedback Mechanisms: Regular feedback can really boost team morale and productivity. Think about setting up a quick weekly check-in or using anonymous surveys to gather thoughts on what’s working and what’s not.
• Resource Allocation: Be mindful of how you allocate your resources. It’s important to ensure that everyone has what they need to succeed, whether that’s access to software, training, or even just a comfortable workspace.
• Goal Tracking: Keep track of your team's goals and milestones. Using a simple spreadsheet or a more advanced tool like Monday.com can help visualize progress and keep everyone motivated.
• Adaptability: Stay flexible! The business landscape changes quickly, so being ready to pivot when necessary can be a game changer. Encourage a culture where team members feel comfortable bringing new ideas to the table.
• Documentation: Maintain clear documentation for processes and projects. This ensures that everyone knows what to do, especially when new team members join or when you revisit a project after some time.
• Technology Utilization: Don’t be afraid to lean into technology. Whether it’s automation tools or analytics software, finding the right tech can ease workloads and provide valuable insights.

By focusing on these operational details, you can create a more effective and harmonious work environment!

• Throughput: Ethereum's Layer 1 can only handle around O(100) pairing-heavy proofs in each block. But with external verification layers, we can ramp that number up to thousands! These layers take the heavy lifting off-chain and just send back a single aggregated result. This helps to cut down on those annoying queueing delays that often feel like extra waiting time for users. (alignedlayer.com)
• Defaults Aren’t Safety: It's important to know that DVN defaults can sometimes be “dead” or change unexpectedly. So, if you’re building production apps, make sure to lock in your send/receive libraries and DVN sets. Don’t just rely on those mutable defaults. (docs.layerzero.network)
• Finality Alignment: When it comes to the fast path, there's economic trust placed in the operators. To provide stronger assurances, consider scheduling a later “hard” checkpoint (think of a recursive SNARK settled on Layer 1). This way, you can get the same level of confidence you would from straightforward local verification. You can check out Wormhole’s published roadmap and partnerships for more on this topic. (wormhole.com)

When to Prefer External zk Verification Layers:

Choosing the right verification layer can make a big difference in how we handle zero-knowledge (zk) proofs. Here’s when you might want to lean towards external zk verification layers:

1. Scalability Needs
   If your application is growing fast or you’re dealing with a lot of transactions, external zk verification layers can help reduce the load on the main chain. They can process many transactions off-chain and only send essential info back to the main network.
2. Cost Efficiency
   Using external verification layers can save you money on gas fees. Since they handle most of the heavy lifting off-chain, you won't be paying as much for on-chain transactions.
3. Privacy Concerns
   When privacy is a top priority, external zk layers shine. They allow you to validate transactions without revealing sensitive data. If your project requires confidentiality, this is definitely something to consider.
4. Interoperability
   If your application needs to interact with different blockchains or ecosystems, an external zk layer could help facilitate that. These layers can bridge gaps and allow for smoother communication between various networks.
5. Optimal Performance
   For applications that need quick response times and minimal latency, external zk verification layers can offer improved performance. By handling processing off-chain, they can speed things up significantly.
6. Experimentation and Flexibility
   If you want to try out different zk proof systems without getting locked into a specific blockchain’s architecture, using an external verification layer gives you the flexibility to experiment.

By considering these factors, you can make a more informed decision on whether to go with external zk verification layers or stick with on-chain solutions.

• You want to achieve sub-minute user experiences while still ensuring robust security down the line. Think about it this way: real-time gaming assets, RFQ fills that help manage risk while you wait for final confirmations, or those high-volume oracle updates that could easily bog down on-chain verifiers. Check out more details here!

---

Concrete numbers you can budget for (2026-ready)

• Ethereum's “finalized” block aims for around 12 to 15 minutes, but the SSF research is shooting for a cool 12 seconds - though that’s not up and running yet. (inevitableeth.com)
• When we look at IBC's end-to-end packet lifecycle, it’s sitting at about 55.4 seconds on average across various routes. This isn’t due to any consensus limit, but more about the timing of relayers and apps. (mdpi.com)
• If you check out CCIP’s per-chain finality table for January 2026, you’ll see some interesting numbers: Avalanche clocks in at under 1 second, BNB around 5 seconds, Arbitrum at about 17 minutes, Base at 18 minutes, and Ethereum at roughly 15 minutes. Just keep in mind that your cross-chain provider will be waiting for these times to pass on the source domain. (docs.chain.link)
• Gnosis OmniBridge gives us a heads-up that zk light clients to Ethereum in production are looking at around 20 minutes for end-to-end transfers (that's finality plus proof). (gnosis.io)
• Finally, the external zk verification layer from Aligned AVS handles around O(10^3-10^4) verifications per block equivalent, batching one on-chain result. The cool part? The gas per proof spreads out with bigger batch sizes, so you can sidestep that pesky verification queue. (blog.alignedlayer.com)

---

How latency targets map to architecture choices

• For “visible on destination <5s” with later settlement:
  • Go for a DVN or a verification layer quorum to get that soft confirmation, and then you can settle with a zk checkpoint or a source-finality-aware proof later on. Let users know the status by showing it as “Received (soft)” first and then switch it to “Finalized (hard).” (docs.layerzero.network)
• Aiming for p50 ≤ 60s and p95 ≤ 3m:
  • If you're working with fast-finality sources like Avalanche, BNB, or many Cosmos chains, local verification through light clients is the way to go. It’s simpler and gets the job done. For EVM routes, you might want to check out external verification layers to dodge that pesky verifier queueing and keep the user experience under a minute. (docs.chain.link)
• Willing to accept 10-20 minutes for high-value settlement:
  • In this case, stick to local verification using zk light clients or native light clients like IBC. This way, you reduce external trust, and it fits nicely with Ethereum’s finality window. (inevitableeth.com)

---

Three practical designs with bill-of-materials and timing

A) ETH→Gnosis governance messages with minimal trust

• Design: The zk light client on Gnosis checks Ethereum's consensus, and the messages come with membership proofs that get verified locally. No need for a committee here!
• Latency: It takes about 15 minutes for ETH finality plus roughly 5 minutes for proofing/relay, bringing the total to around 20 minutes.
• Why it works: This setup shifts the trust boundary to Ethereum's consensus for figuring out where messages are coming from. It's super handy for making parameter changes, but probably not the best for market-sensitive user experiences. (gnosis.io)

What to Watch:

• Keep an eye on proof generation SLOs: monitor the p50/p95 metrics across your prover nodes, including those GPU fleets and any retries.
• Gas costs: BLS12‑381 precompiles can help lower pairing costs if your verifier is just idling; however, for those on BN254 Groth16, it's still pretty affordable to verify, though it comes with some conversion trade-offs. Check out more details here: (blog.ethereum.org)

B) Solana↔EVM in‑game asset movement with sub‑second “play” UX

• Design: We're using a DVN-backed fast path (LayerZero v2 Security Stack) that lets you jump into gameplay in under a second at your destination. After that, a scheduled zk or multi-verifier checkpoint upgrades your soft receipt to a hard settlement a few minutes later.
• Latency: You get a soft confirmation in just a few seconds, while the "hard" confirmation aligns with the source finality or zk checkpoint schedule.
• Why it works: This setup means players can dive right in without waiting. Meanwhile, the treasury and inventory get reconciled only after everything's finalized. You can track the two-stage status right in the UI. Check it out here: (docs.layerzero.network)

What to Watch:

• Make sure to pin your DVN sets; just relying on defaults or “dead DVNs” isn't a good idea. It’s a smart move to add monitors that confirm your configured X‑of‑Y‑of‑N is active on the specific pathway. You can check out more details here.

C) Cosmos appchain → Ethereum L1 asset claims without verifier backlog

• Design: On the Cosmos side, let’s stick with native IBC. For Ethereum, instead of dealing with multiple separate proofs, we can send those proofs over to a dedicated proof verification layer. This layer will aggregate the attestations and then just post a single result to Layer 1, which your destination contract can easily handle.
• Latency: We’re looking at just a few seconds on the Cosmos side and a span of seconds to one block for the aggregated attest on Ethereum. Plus, there’s an optional zk checkpoint down the line for that “hard” settlement if needed.
• Why it works: You won't hit a wall with Ethereum’s pairing-check throughput anymore. Instead, you’re just trading a small external trust budget (which is secured through restaking) to get rid of those annoying queuing delays. Check it out at (alignedlayer.com).

What to Watch:

• Keep an eye on the ICS‑23 proof fidelity and the whole “finality alignment” thing between chains. Just a heads-up: don’t stamp a receipt as final on Ethereum until you’ve got the source height locked down and irreversibly committed in the Cosmos light client. You can check out more about it here.

---

Emerging 2026 practices that actually shrink latency without adding blind trust

• Real-time proving against the head: Succinct has nailed it by proving 99.7% of Ethereum blocks in under 12 seconds using just 16 consumer GPUs. This opens up the door for “prove the head” workflows. Projects can now take safe-head risk bounds into account rather than waiting for full finality, or mix head proofs with economic controls. Think of this as an advanced feature: make sure to align it with user-visible risk messaging and fallback policies. (blog.succinct.xyz)
• Pectra’s crypto precompiles change on-chain math: The checks for BLS12-381 pairing are now on par with or even cheaper than BN254 for each pair. This boosts the chances of using BLS-native verifiers and signature aggregation in bridges. It might be a good time to update your gas models and consider moving away from BN254-only verifiers. (blog.ethereum.org)
• Calldata repricing pushes you to aggregation: With EIP-7623, the hefty calldata verification paths are losing their appeal. It’s better to lean towards recursive aggregation and “result-only” commits to L1. Plus, with EIP-7691 increasing blob throughput, rollups can better sync their own settlement timing. (eips.ethereum.org)
• ZK light clients are being integrated into multi-verifier platforms: Wormhole’s recent roadmap and partnerships indicate that ZK clients might soon be enhancing or even replacing committee trust on certain routes. So, be ready to think about route-by-route capabilities rather than just assuming everything will be uniformly available. (wormhole.com)

---

Implementation checklist: make latency an SLO, not an accident

• Define SLOs by route and message type:
  • For instance, you might say, “Consumer transfers p50 ≤ 60s, p95 ≤ 3m” compared to “Governance messages p99 ≤ 25m with ‘finalized’ guarantee.” Make sure to back this up with the finality method of the chain (like finality tag vs. block depth) and your provider's published policy. Check out the details here: (docs.chain.link)
• Engineer the two-stage UX:
  • Think about naming the stages like this: Status = Received (verification layer quorum/DVN), Finalized (source finality reached or zk checkpoint verified), Settled (destination execution succeeded). Users are much more likely to be chill about staged certainty if they know what’s going on.
• Avoid verifier queueing:
  • If you’re verifying proofs locally on Ethereum, be mindful of your budget for pairing capacity per block. Otherwise, batching through a verification layer can help turn O(n) verifications into O(1) on-chain operations. For more info, check out this link: (alignedlayer.com)
• Gas-aware cryptography choices:
  • The BN254 Groth16 method is still super affordable to verify, and BLS12-381 is pretty much a go-to now, often costing less per pairing. After Pectra, it’s worth re-evaluating your curve choices to trim a few milliseconds and gwei. Get the scoop here: (eips.ethereum.org)
• Finality alignment rules:
  • Don’t label a message as “final” on the destination until the source chain is finalized (or your board-approved block-depth policy is in check) and make sure your proof’s light-client height reflects that. For IBC/ICS-23, rely on VerifyMembership/VerifyNonMembership primitives instead of doing any ad-hoc checks. More info can be found here: (ibc.cosmos.network)
• Monitoring you’ll actually use:
  • Keep an eye on per-route p50/p95 end-to-end; prover p50/p95; batch age; DVN quorum times; revert/retry rates; and have those “proof availability” circuit breakers ready to switch paths or hold up acks when SLOs start to drop. The public CCIP doc cadence is a solid reference for how providers share their finality policies. Check it out: (docs.chain.link)

---

Decision guide you can copy into your PRD

• If your business really needs “<5s to visible action,” consider going for an external verification layer or the DVN fast path. Make sure to clearly differentiate between what can be used and what can be withdrawn, and don’t forget to set up a hard checkpoint. (docs.layerzero.network)
• If you’re aiming for “<60s typical” and working on fast-finality chains, you should lean towards local light clients (think IBC-style) or zk light clients that pull from speedy sources. Just remember, the main bottleneck will be the relayer cadence and the app acknowledgments. (mdpi.com)
• If you want “guaranteed Ethereum-level assurance” and can afford to wait a bit, go for local verification using a zk light client and be ready for a wait time around 15-20 minutes. It’s a good idea to create a user experience that sets the right expectations and organizes the actions that follow. (inevitableeth.com)

---

Closing thought

“Security vs speed” isn’t just some catchy phrase; it’s a crucial aspect you should weave into your bridge’s design. When you go for local verification, you get top-notch cryptographic assurance, which can take a few minutes, especially if Ethereum's involved. On the flip side, those external zk verification layers bring that user-visible latency down to just seconds--but it’s important to clearly plan for a hard finality. The most successful stacks of 2026 will nail both: offering quick paths for a smooth user experience, solid cryptographic settlement for your treasury, and well-defined service level objectives (SLOs) that everyone can rely on. (docs.layerzero.network)

---

References (selected)

• So, let’s talk about Ethereum's finality and the whole SSF background. Right now, we’re looking at around 15 minutes for finality. You can check out more details here.
• When it comes to IBC, the practical latency measurements are averaging around 55 seconds, and they’re using the ICS‑23 verification model. More info can be found here.
• Now, for CCIP, there's a bunch of per‑chain finality methods and their timings. You might be wondering why providers wait for finality--get the scoop here.
• Gnosis is making waves with the OmniBridge zk light client integration, which is guiding us towards an average of about 20 minutes per transfer. Check it out here.
• There are external zk verification layers (Aligned) that focus on throughput and batching economics, especially through the LayerZero DVN model. You can learn more here.
• Let’s not forget about Pectra activation; it involves BLS12‑381 precompiles, gas formulas compared to BN254, and even some notable changes in calldata repricing and blob throughput. More details are available here.
• The proving performance of Succinct SP1 on Ethereum blocks is hitting a real-time proving progress with a 12-second budget. You can read all about it here.
• Lastly, Wormhole’s ZK roadmap and integrations are trending toward multi‑verifier and ZK‑augmented routes. Dive into the details here.