header-langage
简体中文
繁體中文
English
Scan to Download the APP
Partnered With:

When we talk about cross-chain bridges, what are we actually discussing?

Read this article in 12 Minutes
How to define an "ideal" bridge?
Original Title: "What I Talk About When I Talk About Bridges"
Original Author: 0xjim
Original Translation: ChinaDeFi


Getting Started


Have you ever gone hiking and tried to cross a river without using a bridge? I have, and I can tell you it feels terrible.


Just like bridges in the real world, cryptocurrency bridges (along with their fancier cousins: "interoperability protocols" and "universal messaging layers") provide the same value.


They connect blockchains together. Without bridges, moving from one chain to another would be a very painful user experience.


But the encryption bridge is not just a connection, they also allow for translation of language and rules between blockchains.


Bridges enable data to be transmitted and interpreted between different environments. They allow for interoperability between chains.


"But, will the future be multi-chain?" You may have this question.


Uh, yes.


There will always be multiple blockchains - from Cosmos to Avalanche to Aptos to multiple active areas of Ethereum - that are necessary and forever.


These blockchains need a communication layer to coordinate settlements. Otherwise, they will be forever isolated from each other.



Using re:meme to create memes on the blockchain.


Only in the past 30 days, about $5 billion worth of value has been transferred through the bridge. In addition, the bridge company is favored by investors.


Source: Deloitte Digital Research


However, in the past year, there have also been vulnerability exploits worth over $2 billion, either through exploiting core mechanism designs or through exploiting smart contract vulnerabilities.


Holy Grail


How to define an "ideal" bridge?


After a year of hard work in the encryption industry, I believe that secure and reliable mechanism design is the key to restoring user confidence.


Source: Deloitte Digital Research


The safest bridge design should be based on minimal trust, where the bridge inherits the security properties of the two chains it connects.


This is accomplished through on-chain verification: the target chain (i.e. the chain receiving the bridged transaction) verifies the consensus of the source chain and sees that the specified transaction is indeed included in their blockchain.


This is usually done by running an on-chain light client of the source chain by the validating party of the target chain. The light client checks the submitted Merkle root and sees that the specified transaction has indeed been signed by the active validator set of the source chain. Then, the validating party of the target chain can confirm the validity of the transaction and include it in their blockchain.


Goethe-style trading


Running a lightweight client on-chain is both complex and expensive (due to its high computational requirements). It is not scalable - as each validator needs to run a lightweight client for each source chain. This makes it difficult to expand to new chains, and for some it is almost impossible - because different consensus signature schemes are not supported in all execution environments (such as Ethereum validating Tendermint consensus).


So far, only the IBC implementation on the Cosmos application chain has achieved large-scale on-chain light clients (Gravity Bridge, Rainbow Bridge, Composable Finance, and Snowbridge are difficult to scale).


In order to succeed in this regard, extreme standardization is the only way to achieve it - every application chain needs to run Tendermint consensus and adhere to the IBC standard.


In a multi-chain world with different consensus mechanisms, signature schemes, and virtual machines, it is impossible to verify light clients on the chain.


Therefore, a balance must be struck: how many trust assumptions must be made in order to achieve feasibility/scalability?


This is the agreement that many bridge projects have reached with "devils" - to establish a so-called trust zone, which depends on the degree of balance.


Source: LiFi Blog


Off-chain Verification


If it is not possible to conduct on-chain light client verification, then the only possible design space is to do it off-chain.


This is where the protocol differs in implementation.


On the one hand, you have Team Human - Multichain, Wormhole, Ronin Bridge. These all require multi-signature implementation, physical verification of transactions, and verification (i.e. signature) of their validity. Once the threshold is reached, the transaction is considered verified.


These implementations require the entity to run a full node (more powerful than a light client) for verification. Of course, these people can still lie, but assuming that most people rule, the entity will not maintain their reputation through dishonesty.


Team Human's next-door neighbor is Team Economics - Celer, Axelar, deBridge, Hyperlane, Thorchain (and so on). These are similar to multi-signature, but with an added layer of proof of stake. Now, it's not just a matter of trusted entities (here called validators) jointly signing off on the validity of transactions, but there's an economic incentive to not lie, as the validators' staked funds will be significantly reduced if they act maliciously.


These implementations typically also require validators to run full nodes of the source chain (but it is not mandatory). In theory, Team Economics is more secure than the underlying blockchain they are connected to, but in practice, I have not seen it happen.


Next up is Team Game Theory - LayerZero and optimistic bridges like Nomad and Synapse. These implementations break down the bridging process into two independent tasks and suppress coordination between the two task executors.


For LayerZero, they have created the Ultra Light Node, which is essentially an on-demand delivered instant light client. The oracle delivers block headers, and the relay delivers transaction proofs. The two work together to perform the duties of an on-chain light client, but at a lower cost because they are not continuously running.


Optimistic Bridge also has two off-chain agents: an updater and an observer (in Nomad's words). The updater passes a Merkle root of the source chain and has a challenge period (e.g. 10 minutes) during which any observer can question the validity of the passed Merkle root. Incorrect updaters will have their stakes reduced.


In both of these implementations, off-chain proxies need to run a full node to validate transactions. In both of these implementations, collusion between two proxies can also result in erroneous transactions being approved.


However, the Optimistic Bridge requires an "honest minority" assumption to correctly verify transactions - which means that anyone (in theory) can be an agent, so the system only needs one honest participant to work.


Currently, LayerZero has allowed off-chain agents to rely on the trusted reputation of institutions to keep the system running smoothly. Over time, LayerZero hopes to designate <oracle-relayers> for applications to suppress collusion.


Finally, there is Team Security - Datachain/LCP Network. They utilize secure enclaves like Intel SGX to perform encrypted off-chain lightweight client verification - which they call lightweight client proxies. In this case, trust is entirely dependent on the security of the TEE, just like the Secret Network exploit seen earlier, where privacy of all network history can be compromised by obtaining the main decryption key from the SGX side channel.


Ultimately, it is verified by someone or something.


And the target chain validators need to trust that the verification is completed correctly - because they cannot verify it themselves.



On-chain verification


If there is really a way to perform on-chain light client verification?


This is the battlefield of Team Math - Polymer, Succinct, Electron Labs, and zkBridge. These projects are at the forefront of zero-knowledge SNARK research, using succinct proofs to extend on-chain verification of bridges.


From a technical perspective, the verification of the source chain consensus (as well as different signature schemes) is completed off-chain. SNARK proofs are generated by off-chain provers, indicating that this verification has been performed, and then on-chain proofs are conducted on the target chain.


SNARK won't make mistakes because it's...mathematics, you know.



This is the Holy Grail of the bridge!


But not so fast.


ZK lightweight client is an emerging technology with limited scope at present.


That is to say, Succinct is working on the bridge (bidirectional) from Ethereum to Gnosis, Electron Labs is dedicated to the bridge (unidirectional) from Cosmos to Ethereum, and Polymer is developing a lightweight client network (omnidirectional) that spans L1 and L2.


In order to expand to other consensus mechanisms, new circuits are needed, and this work is very difficult.


In addition, the ZK lightweight client needs to determine its finality and cannot use proof-of-work chains like Bitcoin. However, there are some solutions currently under development, such as encoding non-determinism in the circuit of the lightweight client itself.


( For the sake of completeness, I will add a Rollup bridge in Team Math, which proves every state transition, even more trust-minimizing than proving consensus with ZK-SNARKs light clients ).


Thought-provoking truth


After studying hundreds of hours of bridges, my conclusion is that the answer to the "best" bridge is not simple - especially in the near and medium term.


This field is just getting started. People always stubbornly believe that there is only one successful technological solution.


I ultimately lean towards a pragmatic approach. The ultimate winner will not be the best technology, but the best product - built by a team that knows exactly what their users want (in this case, developers) and builds an experience and GTM to deliver value.


As a practitioner in the encryption industry, I can translate Chinese into English without considering the context or industry-specific terms and phrases. English words and phrases, as well as capitalized English words and phrases, should not be translated or omitted, for example: ZKS, STARK, SCROLL -> ZKS, STARK, SCROLL. English characters in a hyperlink should not be translated and should be returned directly, and the hyperlink should not be omitted. When the content only contains punctuation marks, the punctuation marks should be returned as they are. HTML tags in the content should not be translated, such as

, , ,

, etc. If an HTML tag contains English characters, they should be omitted and returned directly. The content in a hyperlink should be preserved and not translated. All Chinese characters should be translated.

As a developer of encryption applications, I understand what application developers want. I believe that a good bridging product should be like this:


Technical Mix


Technology itself is not a product - it makes products possible. The hybrid combination of security models can create a win-win experience for users.


I believe that Team Math is the right direction, but its effectiveness is limited. They prioritize scalability over trust minimization (i.e. the ability to expand to new chains).


Team Game Theory and Team Math working together could be the all-star lineup we need.


Implementation of the first stage of trading Optimistic bridge - with challenge period and honest minority trust assumption. ZK bridge with minimized trust for verification during the return journey.


Another approach is to build modular stacks and insert additional security models (such as LayerZero, Connext, and Hyperlane) over time for corresponding mixing and matching.


Another entity assumes the ultimate risk

‍

When it comes to bridges, finality is key. Bridge protocols require absolute certainty that a transaction has occurred on the source chain before transmitting it to the target chain.


Unable to execute cross-chain rollback.


In instant finality chains (such as Cosmos application chains built on Tendermint), this happens within seconds (i.e. one block). However, other chains take longer to reach finality, some requiring a buffer period to consider the probability/economic feasibility of reorganizations.



The ultimate deterministic definition of deBridge


When sending transactions from Ethereum, users do not have to wait for ~12 minutes to get final confirmation of the transaction. However, for Optimistic rollup, this situation is exacerbated due to the 7-day challenge period.


The final deterministic delay will need to be abstracted from the users, and other participants will need to bear the risk of reorganization.


Configurable Risk Preferences

‍

除了抽象出延迟之外,还需要从用户中抽象出风险的变化。

Apart from abstracting the delay, it is also necessary to abstract the changes in risk from the users.


Applications should control their risk thresholds and customize them based on use cases, amounts, and target chains. For example, NFT transfers on BSC should have different thresholds than liquidations on Cosmos.


LayerZero, Synapse, and Hyperlane allow applications to determine their risk preferences.


For LayerZero, applications can choose a trusted pair and a timer.


For Synapse, applications can choose their fraud window based on use cases.


For Hyperlane, applications can even choose the consensus mechanism they want (Team Human, Team Economics, Team Game Theory - called Interchain Security Modules).


This is where bridge aggregators like Socket and LiFi are particularly useful, because different bridge implementations can also be configured by the application program.


BD is very important


From a technical perspective, this is not a product, but rather a top priority for a team.


Each project is well-capitalized, entering the bear market, absorbing top talents, and innovating at the forefront of cryptography.


However, there are no applications on top of them. Where are the applications?


So far, only Token transfer protocols (Connext, Hop, Across, Stargate) have been successful. The highly acclaimed use cases in the NFT game asset market and cross-chain governance have not yet been realized (except for DeFi Kingdoms).


This is not a "build it and they will come" space. Bridge is a developer platform that requires the creation of a vibrant application ecosystem on top of it.


Without applications, there are no users. That's why business development and integration are crucial to the success of a project.


The application will follow the funds. The determining factor for the winner may not be technology, but rather relationships, integration, and business factors.


For assets, chain connections, and use cases, the use of bridges may follow a power law.


Honesty


The strength of a bridge depends on its weakest link (i.e., the one that may be vulnerable to a 51% attack). This is a huge obstacle for future multi-hop bridges.


Most smart contract implementations are mutable. Upgrades are semi-periodic. There is always someone/something with administrative privileges.


An bridge that allows applications to configure their risk preferences, but also introduces attack vectors where attackers can infiltrate the application's contract and disable any verification process for malicious transactions.


The protocol disputes are resolved by governance or multi-signature. Human errors are introduced into the equation.


Even ZK circuits are not completely trust minimized. We believe the circuits are written correctly. We trust that the prover software has no errors. We trust that the target smart contract can correctly interpret the circuit.


The power of project branding, as well as the ideal solution of slowly and systematically releasing secure code, should address these issues.


Honesty with developers in a frank and rational manner will be greatly beneficial.


Front Road


I believe that in the next 2-3 years, we will see explosive growth in the deployment of application-specific rollups.


There are many solutions that can provide services for this explosive growth: OPStack, Arbitrum Nova+Nitro, Fuel, Polygon Supernet, Avalanche and its subnets, Scroll, Polygon Hermez, Consensys zkEVM, Starknet, zkSync, Celestia, Astria, Saga, Dymension, etc.


However, the bridge seems to be the missing piece in all of these solutions.


How do we ensure the bridging from app-rollup to app-rollup? Companies such as Slush, Constellation Labs, Sovereign Labs (as well as LaGrange and Herodotus) are all considering this issue when creating application rollup SDKs.


How do we provide out-of-the-box bridges for these application-as-a-service rollup solutions? Hyperlane is researching this issue, but it is a difficult problem to solve.


How can we optimize the efficiency of multi-chain capital and eliminate bridge vulnerabilities without sacrificing user/developer experience?


These issues are all subject to observation.


Original article link


Welcome to join the official BlockBeats community:

Telegram Subscription Group: https://t.me/theblockbeats

Telegram Discussion Group: https://t.me/BlockBeats_App

Official Twitter Account: https://twitter.com/BlockBeatsAsia

举报 Correction/Report
Choose Library
Add Library
Cancel
Finish
Add Library
Visible to myself only
Public
Save
Correction/Report
Submit