header-langage
简体中文
繁體中文
English
Tiếng Việt
Scan to Download the APP
Partnered With:

Detail Shared Sequencer: Shared sequencing, aggregation theory, and vertical integration

Read this article in 40 Minutes
This paper analyzes the shared collator: the key technologies that are highly resistant to review, easy to deploy, interoperable, fast determination, and real-time. The theory of convergence provides a new perspective and vertical integration guides its f
Title: The Shared Sequencer
Original article by MAVEN11
Kxp, BlockBeats


Imagine if Rollup "out of the box" could achieve a high degree of censorship resistance, ease of deployment, interoperability, rapid determinism, activity, and democratization of MEVs. This may seem like a grand goal, but with the advent of shared collators, this imagination may soon become a reality. However, not all rollups are created equal, so we have to consider how to distribute rewards and MEVs on a shared sorter network. In this article, we will explore how a shared sorter network is implemented and the attributes that can be implemented.


The Shared Collator Network was introduced primarily by Alex Beckett, and later by Celestia and Evan Forbes of the Espresso Systems team (along with Radius), and a new article by Jon Charbonneau that covers the subject in greater depth. Josh, Jordan, and the Astria team are building the first shared collator network for production. Astria's Shared Collator network is a modular blockchain that aggregates and sorts Rollup transactions without executing them.



In the Astria setup, the collator sends ordered blocks to the DA layer and also to the Rollup node. Rollup gets a soft deterministic guarantee from the collator and a hard deterministic guarantee from the DA layer (after the blocks are identified), and then they will execute valid transactions.


A shared collator network is essentially a Rollup-compatible set of collators that, as the name suggests, can serve different rollups. There are various trade-offs and properties, which we'll get into later. First, we must describe the most important properties of the collator (or group of collators). In Rollup, the main requirements for a collator or group of collators are censorship resistance or activity (some of which comes from the base layer, as well as security). This means that valid transactions submitted to the collator must be included in the chain for a limited time (the timeout parameter). Sharing the collator group only needs to ensure that the transactions are contained in the block (that is, crLists).


Satisfying both censorship resistance and immediacy is quite difficult, as we outline in Modular MEV Part II. In a consensus algorithm such as Tendermint, you can be sure to recover after an attack. But, in the case of an attack, you lose immediacy. Basically, requiring all other collators to sign a block, rather than choosing a custom master node, may not be the best choice. While this improves censorship resistance, it comes at the cost of "centralization" and MEV extraction to a single master node. Another sorting mechanism available can be likened to Duality's Multiplicity, which is the gadget they use for non-master nodes (or collators) to include other transactions into blocks. Overall, censorship resistance and immediacy after an attack are difficult to achieve in most consensus protocols.


Another possible consensus algorithm is HotStuff 2, which ensures immediacy in the event of an attack.


What it does allow is to avoid waiting for a maximum network delay (timeout) to select a new master node under review or unsigned conditions. The reason it could be an interesting consensus algorithm for decentralized sets of sorters is that it solves the problem of immediacy in consensus without adding additional stages. If the master node knows the maximum lock (the maximum number of participants agreeing to a particular output) and can convince the honest party, the problem is solved. If not, the honest master after a particular point can take charge and assist the next master node. For example, the Hotstuff node does not need to confirm the switch message before notifying the new master node, but can simply switch to the new view and notify the new master node.



The difference with Tendermint is that although both are in two phases (Hotstuff1 has three and Hotstuff2 has two), Tendermint has linear communication but is not responsive, whereas Hotstuff2 is responsive. If there is a series of honest Lord nodes, the protocol responds positively because all steps except the first master node proposal depend on the amount of information obtained from the previous step. In a shared collator setup, this allows the protocol to achieve better immediacy without having to fall back to the bottom layer, while not eliminating the possibility.


Building a shared collator group


A set of collators are allowed to submit transactions to the clearing layer (the layer where Rollup resides). You can join this collator group, provided certain requirements are met and the required number of blockers is not reached. This can optimize latency, throughput, and so on. These requirements are similar to those for becoming a verifier of a blockchain. For example, you must meet certain hardware requirements, as well as a starting mortgage, especially if you want to provide certainty with financial conditions.


The shared collator group (or any decentralized collator group) consists of several components that work together to ensure proper processing of transactions, including:


1. For each Rollup  JSON-RPC is provided for transactions to be submitted (for non-full-node runners) to nodes as memory pools, then built and sorted. In the memory pool, some mechanism is needed to determine the queue, as well as the transaction selection process, to ensure efficient building of blocks.


2. Block/batch building algorithm, responsible for processing transactions in the queue and converting them into blocks or batches. This step may also include a compression step to reduce the size of the resulting block (call data compression). As mentioned earlier, this should be separate from the proposer, which is essentially PBS. Data can be compressed in a variety of ways, for example:


    a. No RLP encoding - however, this may require a decentralized set of collators to help regulate data transfer between nodes, thus saving space.

        b. Omit the nonce (the unique number that validates the data in a particular block) -- it can be recalculated at execution time by looking at the previous state of the chain.

        c. Gas Price simplification - Set Gas based on a fixed price range.

        d. Gas simplification - In addition to Gas pricing, there is also a Gas numbering system.

        e. Replace addresses with indexes -- Rollup can store an index of mapped addresses instead of storing full addresses.

        f. Use scientific notation to represent values - The value fields in Ethereum trades are denominated in wei, so the values are large. You cannot omit numeric fields or reduce them to a fixed set of values. However, you can write it as a scientific notation to optimize data storage:



-- Omit Data fields: Data fields are not required for simple transfers, but are required for more complex transactions.

Replace individual signatures with BLS aggregate signatures: Signatures are the largest component of Ethereum transactions. Instead of storing each signature, you can store BLS aggregate signatures for a specific number of transactions. You can also check the BLS aggregate signature against the message set and sender set to ensure its validity.

Use the From field as an index: As with the To field, you can use the From field as an index for the map.

An interesting concept of "modular" design is that you can adapt and trade off as needed to make it work for your Rollup.


3. The point-to-point layer will allow collators to receive transactions from other collators and propagate blocks after building. This step is essential to ensure that the shared collator runs efficiently across multiple rollups.



4. Share the primary node rotation algorithm of the collator set (no consensus is needed in the case of single primary node election). You can choose to only set the master node rotation algorithm, or go with Duality's proposed multi-concurrency block producer (multi-concurrent block producer) The route.


5. Consensus algorithms, such as the Tendermint or Hotstuff2 mentioned earlier, can ensure that the Rollup node agrees with the sequence proposed by the ledger.


6. RPC client used to submit blocks/batches to the underlying DA+ consensus layer to allow blocks/batches to be securely added to the DA layer, thus ensuring "final" certainty and making all transaction data available on the chain.


7. Separate builder and blocker roles to ensure fairness and consistency, and avoid MEV theft. Also remove the sort performed, which is important for optimizing efficiency, reducing PGA and increasing CR.


The Rollup node receives ordered blocks from the collator for soft commit and ordered DA layer blocks for hard commit.


Calldata is first published to the underlying network, where consensus is run to ensure transactions between the user and Rollup. The Rollup node then executes the transaction and submits a state transition function to the canonical Rollup chain. The shared collator network provides immediacy and censorship resistance for Rollup. Rollup maintains its sovereignty because all transaction data is stored in the grassroots, which allows them to fork from the shared collator at any time. The state root of the Rollup state transition function (STF) is calculated from the transaction root (input) sent from the shared collator to the DA layer. In Celestia, state roots are generated when data is added to the chain and consensus is reached. Since you already have the transaction root (and all available data), Celestia can provide a small proof of inclusion for light clients (Rollup nodes run on Celestia).


To provide the user experience the user expects, the Rollup node receives ordered blocks (also sent to the DA layer). This provides Rollup with a soft deterministic guarantee that the blocks will eventually be sorted in the order they were ordered on the DA layer when the Rollup node executes the transaction and provides the new state root.


Block creation with Slot


To determine when the block was created, the collator needs to set the slot. The collator should submit the batch at a fixed interval (usually X seconds), where X is the slot time. This ensures that transactions are processed promptly and efficiently, because otherwise the primary node of a particular slot would time out and lose the signature bonus (and execution bonus). For example, Celestia's block time (according to GitHub specifications) is about 15 seconds. Since this is known, we can make a number of assumptions, from shared collator sets to DA layers and Rollup  Node, how many "slots/blocks" we might load into the final block. Consider Tendermint or Hotstuff2 optimizes in this regard.



Multiple batches of transactions can be submitted in the same slot, provided that the design includes a mechanism that allows the Rollup full node to efficiently process them into a single block (within the time period and timeout parameters). This helps further optimize block creation and ensures that transactions are processed quickly. In addition, slot can be used to facilitate the election of the collator master node. For example, you can randomly select a slot master node from the pledge pool based on the pledge weight. Doing this in a way that maintains confidentiality and uses methods similar to secret leadership elections is the best option to minimize scrutiny; Or even the setup of distributed verifier technologies such as Obol/SSV solutions. Latency and slot time have a significant impact on block commit and build on protocol. So we need to study how this affects the system. Bloxroute has done some excellent research and data points on Ethereum in particular. In MEV-Boost, a participating blocker (the verifier or, in the case of Rollup, the sorter) requests a GetHeader from the secondary. This gives them block bid value, which is the value of a particular block. This is probably the highest value block received each time. For each slot, the verifier typically requests the GetHeader about 400ms after the slot starts -- because there are so many verifiers, the relay often needs to submit countless requests. This is also the case for large groups of shared collators. That means you need the right infrastructure to facilitate the process.



Relays also help to facilitate the separation of builder and blocker, as well as verify that the builder is building the right blocks. They also check that fees are paid correctly and act as DoS protection. In addition, they are basically custodians of blocks and handle the registration of verifiers. In an unbounded sorter system, this is especially important because you need to keep track of who participates and who doesn't (for example, the synchronization layer discussed earlier).


Regarding block out times (i.e. blocks submitted by the builder), they usually occur around 200 milliseconds. Although, like GetHeader, there are considerable differences, they mostly start running about 200 ms ago/after. If the builder sends blocks to multiple relays, there is considerable delay. Bloxroute also investigates what happens when blocks are sent to multiple relays. As you might expect, the delay in the propagation of blocks to more relays is greater. On average, the second relay takes 99 milliseconds to use the block, the third takes 122 milliseconds, and the fourth takes 342 milliseconds.


What we may have learned in the last few months is that RPC is very important to blockchain. This can be a huge burden if you don't have the right infrastructure in place, and having the right RPC options is critical. In this case, RPC is important for retail investors who send their transactions to the RPC (and public memory pool). Bloxroute did a small test of 20 transactions sent to various RPCS and measured the time it took for each transaction to be included in the block.


Source:Bloxroute Labs 


Interestingly, some RPCS include transactions after several blocks, depending on which builder wins in the next block. The more the RPC sends the transaction to the builder, the higher the likelihood of fast inclusion. Although it is possible for a transaction sponsor to take advantage of their unique order flow location to target a particular builder or even build their own blocks.


They are also interesting in Ethereum's relay performance statistics. This gives us a deeper understanding of how PBS works in a multiple verifier/builder/relay world, which is where we hope to go with Rollup upgrades. Metrika has some great statistics on this, and all the data points are credited to them.


Note that a missed bid occurs when a successor is expected to make a bid but does not. The expectation of the object comes from the verifier registered to a particular trunk for any given slot. This is not a relay failure per se, nor is it handled at the protocol level.


Source: app.metrika.co 


If a marking fault occurs (such as a relay providing invalid blocks) and it is responsible, it is counted as a marking fault. These are usually not that frequent, and most often are registration preference failures (that is, registrations where Gas limits or fees do not match a particular verifier). Much rarer are consensus layer failures, where tags do not conform to Ethereum consensus layer rules, such as slot errors or parent hashes that do not align with previous blocks.


In terms of latency (such as the time it takes the verifier to receive the bulk built by the builder), the data is very consistent. This is despite some outliers, such as the request's relay being in a different geographical location from the selected verifier.


Source: app.metrika.co 


Regarding the builders, the total number of builders on MEV-boost is about 84, with the top three builders building about 65% of the built blocks. Although this may be misleading, since these are also the longest running builders. If you narrow down the time frame, the results are similar. The actual number of active builders is much smaller, at 35 in the past 30 days and 24 in the past week. Competition is fierce, and usually the strongest builder wins. An exclusive flow of orders may already exist, which only exacerbates the situation. We expect the builder distribution to remain relatively centralized (as this is a competition for optimal order flow and hardware optimization) unless we make significant changes to the setup. While this isn't a fundamental problem, it's still a central force in the stack, and we'd love to hear ideas on how to challenge the status quo here. If you're interested in learning more about this (serious) issue, we highly recommend reading.Quintus  Articles on order flow, auctions, and centralization.


For the Builder role in the modular stack in the future, we are pretty sure (at least in the Cosmos SDK setup) that we will see a Builder Modules setup similar to Skip/Mekatek. Another solution is a Suave-type setup, such as a specific global builder chain that provides block building and bid preference services for any number of chains to ensure PBS. We'll explore this solution in more depth later and provide answers to some of the unanswered questions here.


For relays, we highly recommend reading an article by Frontier Research's Ankit Chiplunkar and Mike Neuder of the Ethereum Foundation called Optimistic Relays and Their Place ( Optimistic relays and where to find them ) . This article details how relays work in MEV-boost, their current trade-offs and running costs, and some changes that could increase efficiency. Interestingly, according to Flashbot's estimates, the current cost of running a relay in MEV-Boost is around $100,000 / year.


certainty


Before we talk about the certainty of modular blockchains (as they currently are), let's take a look at our previous "Modular MEV" article. Note that this is not an "official" or comprehensive view of finality, but we think it most accurately represents the subtle nuances of Rollup certainty for easy understanding.


Pending_On_L2: The Rollup collator represents a soft promise that a user's transaction will eventually be committed and finally confirmed at the base layer of its security.


Finality_On_L2: The collator has promised Rollup's state transition function, and the block has been added to Rollup's specification chain.


Pending_On_L1: The input or output/state transition function of the transaction has been published to L1, but the proof of validity has not been published, or the arbitration period has not ended - this requires Ethereum two consecutive epochs. This is the point at which most Optimistic Rollup states that certainty has been reached, but there is still an arbitrary 7-day challenge period at this point, according to the canonical cross-chain bridge.


Finality_On_L1: For Optimistic Rollup, the arbitration period has ended, or a published and verified proof of validity has been confirmed by a supermajority in two successive epochs.


Now, in the sovereign shared sort Rollup, this looks a little different, let's try to illustrate it graphically:



In this case, theoretically we can get certainty on L1 before L2, etc.? Yes, in this case L2 is sovereign after all. This is assuming there is no proof of fraud and challenge period, or that you are using proof of validity.


So how do we achieve these levels of finality? Block determinism is implemented when a block is added to the canonical chain, and it cannot be withdrawn. However, there are some nuances here, depending on the full node or the light node. In the case of ordered blocks, it is determined once it is included in the DA layer block. Blocks (with state roots) are executed by the Rollup full node/verifier, which provides them with the guarantee of a valid state root derived from the base layer ordered block. For determinism beyond the full node, such as for light clients or cross-chain Bridges, the validity of the state root must be assured. Here, you can use one of the methods described below. In addition, another approach is also to hold the verifier accountable for the correct proof of the state root (Optimistic line), through guarantee money and subsequent proof of fraud. In addition, you can provide proof of validity (ZK).


Different ways to achieve block certainty:


1. Adopting proof-of-work (PoW), LMD+Ghost, Goldfish, Ouroboros (PoS) and other probabilistic methods.


2. A demonstrable method by which sufficient committee members sign blocks. (Example: Tendermint 2/3, Hotshot2, or other PBFT types)


3. Depends on the order of transactions/blocks on the DA layer, and its rules, i.e. canonical chain and fork selection rules.



We can achieve different types of determinism through different mechanisms.


One type of certainty is "soft certainty" (such as pending), which can be achieved by a single leader election. In this case, each slot will have only one or zero blocks (committed or not committed), and the synchronization layer can safely assume the sequence of transactions in these blocks.


The other kind of certainty is "provable certainty," which provides a stronger guarantee (essentially final) than soft certainty. To achieve provable certainty, most collators must sign the block, thereby indicating that they agree that the block is canonical. While this method is nice, it may not be necessary if a single leader election has already been implemented, as it basically guarantees block sorting. Obviously, it depends on the particular leadership selection algorithm implemented. For example, is it 51% implementation, 66% implementation or single leader (preferably random (VRF) and secret election). If you want to learn more about certainty in Ethereum, read our highly recommended oneThis article, and the articles we will recommend later for the unbounded collator set.


Licensed, semi-licensed or unlicensed.


To prevent potential DoS attacks, economic barriers must be set to join the collator group and submit transactions to the collator layer. In both bounded (a finite number of collators) and unbounded (an infinite number of collators) groups, economic barriers must be set to submit batches to the DA layer to prevent the synchronization layer (which propagates blocks between collators) from being slowed down or subjected to DDoS attacks. However, the DA layer itself also provides some protection because of the cost (da_fee) required to submit data to it. The margin required to join the unbounded group should cover any additional costs necessary to prevent the synchronization layer from being spammed. On the other hand, the margin required to join a bounded group will depend on demand (balance from a cost/income perspective).


For an unbounded collator set, we cannot achieve provable certainty in the collator layer (because we never know exactly how many active voters/signers there are). On the other hand, provable determinism can be achieved in a bounded sorter group by most of the sorter signing blocks. This does require the synchronization layer to know the collator layer and the number of collators active at any given time, which is some additional overhead. In a bounded collator group (say up to 100), you can also optimize the number of collators to improve "performance," although at the expense of decentralization and censorship resistance. The importance of bounded groups and economic guarantees in providing "fast" provable certainty is also decisive.


The unbounded sorter and bounded sorter types are also found in traditional blockchains, such as PoS (Casper+ ldm-Ghost) in Ethereum, which uses an unbounded type, and the Cosmos SDK/Tendermint based chain, which uses a bounded type. An interesting thought is, would we expect to see something like proof-of-equity economics and choice from communities around shared collators? In this regard, we have seen a move towards centralization of some entities (so unbounded doesn't matter if you already have some large proof-of-interest providers/pools). Although they "mask" centralisation, after all, you can still mine for yourself if you want to. From an ideological point of view, choices should almost always be unbounded - but remember that economic principles make them very similar anyway. The economics of the fees you pay should still be the same regardless of who is involved, such as the cost of DA and the cost of hardware (although this may be reduced by the amount of proof of equity and experience you have allocated, and the infrastructure that is already running efficiently). Even in the bounded PoS world, we have seen a set of infrastructure providers emerge as the largest and most common validators on almost any chain. On most Cosmos chains, the correlation between verifiers is already very large, and this also certainly poses a danger to the decentralization and censorship resistance of the chains. Nonetheless, a very different fact is that any retail investor can make any number of proof of interest against any verifier of his choice. Unfortunately, this usually gets assigned to the top of the list, and life goes on. Again, we ask: do we expect a similar economic model to emerge in a modular world? One would hope not, but as specialisation develops, you often need the best fit - and they tend to be professional proof of equity providers. We will also cover these economic issues in a separate section later.


However, an important issue to keep in mind among all these issues is that the most important is end-user authentication, which is available to anyone, no matter where they are (even at the Pyramids of Giza), through light clients and DAS.


Source:@JosephALChami


Here are the tradeoffs and advantages of bounded versus unbounded collators:


unboundedsortOrgan set:


· Anyone with enough bindings/pledges can be a sorter = highly decentralized.

· It is impossible to have a single leader election because the sorter is basically infinite.  

· Non-single leader elections can be conducted through VRFS, but it is difficult to determine VRF parameters because it is not known how many sorters there will be. If possible, this should also be a secret leadership election to avoid DoS attacks.  

· If there is no leader election = Waste of resources problem: Block building is essentially free competition, whoever submits the first valid block/batch wins, and everyone else loses. · · There is no provable certainty at the collator level, only probability: e.g. LMD Ghost+Casper 

· Certainty is achieved only after the batch is written to the DA layer (limited to the underlying block time, 15 seconds in the case of Celestia).  

· Unbounded sets have "better" censorship resistance than bounded sets.


boundedsortOrgan set:


This is one of the solutions for Ethereum single slot certainty, as well as having super "majority" committees.


· The number of collators allowed at any given time is limited.  

· Bounded sets are more complex than unbounded sets.  

· Single leader election can be implemented, providing strong certainty for the sequencer layer.  

· The synchronization layer needs to understand the set of collators to determine which blocks are valid.  

· Write collator sets (or set changes) to settlement layer blocks (e.g. fork selection rules), and these blocks are written to DA layer, allowing synchronization layer to independently determine the collator set. For example, this is Sovereign Labs Rollup  Collection changes are written to the proof of validity published to the DA layer.  

· Strong deterministic guarantees for the sorter layer may not be necessary if the DA layer is fast enough (however, most current unoptimized settlement layers are set to have at least a block time of more than 10 seconds).


There is considerable design room for how to monitor these collator sets and add or remove new members. For example, will this be done through Token holder governance (so how do you think about many different tokens and rollups using collections?) . This means that signal changes off-chain may be achieved through social consensus (for example, in the case of Ethereum). However, keep in mind that the actual on-chain consensus is clearly already in place and that penalties for violating consensus rules already exist.


An economic mechanism for sharing collators


The economics of a shared sorter network allow for some interesting choices. As we discussed earlier, the verifiers in a shared sorter network are not that different from a typical L1 verifier. The network it participates in is simply more optimized to perform one task, namely receiving intent (formerly PBS), thus proposing and ordering transactions. Just like a "regular" verifier, there are revenue and cost components. On both sides of the equation, the verifier participates in a network with a lot of flexibility, similar to regular L1.


Revenue comes from users or rollups they eventually wish to interact with paying a fee to use the shared collator. This fee may be a percentage of the extracted MEV (input numbers may be difficult to approximate), a cross-chain value transfer, Gas, or a fixed fee per interaction. The most appropriate revenue solution may be that the value paid to the shared collator is less than the additional value gained through the Rollup shared collator and the benefit of gaining shared security and liquidity. The downside is that it's hard to quantify the benefits of decentralization in another part of the stack. However, as the shared sorter network grows into its own ecosystem, its ability to extract fees is likely to increase. This is largely due to their natural ability to aggregate easily, with some economies of scale. As more rollups and applications join the network, more and more cross-domain MEVs can be extracted.


Cost-wise, shared sorting networks also have competing options. They can do this by funding the cost of publishing in the DA layer, even for the Rollup  The cost of interaction on the application easily funds their network usage. This is similar to the strategy used by Web2.0 companies, where you take the initial loss when acquiring a user (or Rollup) in the hope that their revenue in the long run will exceed the expenses. A more novel or crypto-native approach is to allow Rollup  Pay DA fees with its native Token. Here, the shared collator layer assumes the Token and Rollup  required to publish data on the DA layer. Pricing risk between native tokens. In essence, it is still a shared collator front-end cost, but it creates ecosystem consistency by acquiring tokens from "vendors" (i.e. Rollup). This is similar to the warehouse construction we discussed in the AppChain paper, where different forms of DA can be utilized to reduce costs. Different DA layers will offer different pricing due to utilization, the ability for users to easily validate different block size choices through lightweight clients, or directly. Finally, the shared collator can also batch transactions before publishing to the DA layer. In the case of ZKR, this reduces transaction costs by a certain amount of transaction balancing, whereas in the case of ORU, you can do various batch Gas optimizations, which we are currently doing in various Rollup  You can see it from above. This will reduce the amount of data that needs to be published to the DA layer, thereby reducing the cost of the shared sorter network and increasing the profitability of the entire network. This comes at the cost of limiting interoperability and changing block determination times (as described earlier, deterministic on L1).


Overall, the economics of a shared sorter network allow for some interesting experimentation and guiding strategies. We estimate that the key difference will be the size of the ecosystem, so the number of cross-domain MEVs is greater than the cost. We also strongly recommend checking out the Espresso team for shared collatorsBlog postThey also cover the economic trade-offs (and positives) of these types of networks. To show why The incentive to use shared collators (in addition to economic factors) can be considered from the perspective of aggregation theory.


Aggregation theory and shared sorter


Another way to describe the features brought about by shared collators is through the perspective of aggregation theory. Aggregation theory is the concept of how platforms or aggregators can integrate other platforms and their users in a systematic way to gain significant user attention. You are essentially shifting the game from the allocation of scarce resources (for example, block space) to the need to control rich resources (again, block space makes sense in this example). The theory of aggregation is actually the integration of suppliers and products (i.e. Rollup  And block space) aggregated into a superuser experience to provide services for an aggregated user base. As the network effects of these aggregators grow, the relationship becomes increasingly exclusive. As this happens, user experience becomes a key differentiator between similar Settings. Rollup  if there are incentives to attract new users (e.g. good user experience and better interoperability) then Rollup  Moving to its own network or a different setting is unlikely -- network effects push new providers and new users to join. This creates a flywheel effect, not only from the perspective of suppliers and users, but also from an aggregated anti-censorship perspective.


Source:Aggregation Theory 2015, Ben Thompson


In the context of shared collators, aggregation theory can be regarded as a variety of Rollup  "Combinations" and alliances, all of which take advantage of similar vertical parts of the stack -- enabling users to have the same experience no matter where they are, while strengthening themselves and others.


Vendors (such as Rollup) are theoretically not unique to a shared collator set, but in practice, a shared collator set, its Rollup  And users benefit from a cycle of network effects that lead to these. The usage of These benefits make it possible to And users are easier to integrate into a shared stack because they have more to lose if they don't participate. Although when you only have two. These benefits may be hard to see when sharing a set of collators, but as you add more and more Rollup  And users into the equation, these benefits become clearer. The shared collator set is directly relevant to the user because they order their transactions, even if the user himself does not know that they are interacting with it, because from their point of view they are just using the Rollup that they have reason to interact with (which means that the order/collator becomes exclusive). The only cost of these collators is really the cost of the hardware to run them, as long as the block space and the tokens protecting it are of value to the end user. Transaction fees are digital, paid by the user's wallet, and perhaps in the future, even abstracted through advances such as payment hosting in account abstraction (however, someone will have to bear the cost of DA, sorting, and execution).



It makes more sense to consider Josh and Jordan's previous company at Astria: Google. Since their inception, Google products have been inspired by the idea of AT, particularly in Google Search, which is created by modularizing individual pages and articles, making them directly accessible through the global search window.


In the shared collator collection case, use Rollup  The acquisition cost of the users (users who share the collator set) is getting lower because they are likely to be attracted to the set as the number of vendors (Rollup) increases. This means that in most cases an aggregator (or multiple aggregators) has the potential to be a clean sweep because the value of the aggregator increases with the number of vendors (as long as the user experience is good, of course). In contrast, on a single sequential network, customer acquisition is limited to a single network and its applications. If the user wants to use in different Rollup  Rollup  Applications, they would have to (within the current limits) exit the network entirely. This means that user engagement and value is not very high, and it also means that at any moment, if another Rollup  Ecosystems are highly valued (or more incentivized) and capital may be lost.


Attributes and trade-offs are summarized


attribute


The shared collator set is a Rollup  Network, for multiple Rollup  Aggregate and sort transactions. Eg. These things Share the same collator. This pooling of resources means that Enhanced economic security and scrutiny resistance, which can provide fast soft certainty assurance and conditional crossing. Trade.


Now, in the Rollup  that shares the same collator set; There's a lot of noise about atomicity, mostly around the question of whether it's atomic by default -- it's not. However, if the Rollup  in question; Implement each other's state transition functions (STFS) as dependencies between them, involving conditional transactions, and they can indeed achieve atomicity between them -- as long as their slot/ block timing is aligned (as with the shared collator set). In this case, to get atomic interoperability, you really just need to run the light client of chain B on chain A, and vice versa (similar to how IBC works). To further enhance the interoperability of security measures (beyond trusting a single full node as a light node), you can implement ZKP (Proof of State) to solve the "predictor problem" of ensuring state correctness. This will allow people to see more clearly if conditional transactions or something similar have touched the normative cross-chain bridge between them. Proof of fraud is also a possibility, but obviously leaves a period of challenge (meaning that a third party emerges to bear the cost of this risk). Also, in the case of a light client (rather than a full node), it will be at least one block behind due to waiting for the signature header+ proof of fraud window (if any).


We believe that the "bridge across chain" problem is most likely to be solved with lightweight clients and zero-knowledge proofs. The challenge with using lightweight clients in this case (as opposed to smart contracts) is that the hard forks (upgrades, etc.) on the Rollup node side need to coordinate with each other to keep them bridged (just as IBC needs to enable the same status module). If you want to learn more about this particular topic (and how to tackle it), we highly recommend you check this outpresentation.


Shared collators are very scalable because they do not execute and store any state (as centralized collators do today). The Rollup nodes themselves do the same (unless they want atomicity between them - for example, lightweight client/state proof). These nodes execute only their Rollup  Valid transactions, and any conditions with which they are valid cross domain transactions. If Rollup  Nodes must have multiple Rollup  Execute and store state, which hinders scalability and reduces decentralization (and thus resistance to censorship). This also reinforces the concept of block-builder separation (PBS). We still need to completely separate the builder from the blocker, though. In the current setup, the collator is essentially a builder and blocker (although they do not execute transactions). An ideal setup might be that a collator exists only to blindly sign blocks set by highly optimized builders and ensure that blocks are implemented correctly (while providing a high degree of economic certainty and resistance to censorship for this authentication). In this way, they can provide a high degree of security and commitment to soft certainty. Node.



For cross Rollup  Conditional transactions, they also exist to help make rollerbacks. The node (performer) provides the intermediate state root that implements Rollup  The atomicity between them.


weigh


The timeout parameter mentioned earlier has some interesting implications for MEV and transaction inclusion, depending on the master node/consensus mechanism of the collator set. For example, if the timeout parameter is described as relatively short in our application-specific chain paper, it is critical that the blockers in the decentralized collator set publish the data as quickly as possible. In such a world, you can see competition between "verifiers" competing to be the master node and bidding on the DA layer for block space until it no longer adds up.


As Evan covered in the original lazy Collator post on the Celestia forum, waiting for transactions to be published to the base layer (in this case, Celestia) before executing them is very inefficient. Because now you're limited by the base layer's block time -- that's too long a wait for the user experience. For better user experience, the shared collator is Rollup  A soft deterministic commitment is provided (as described earlier), which provides users with the user experience they are used to in existing centralized rollups (while maintaining decentralization and high censorship resistance). Soft commitments are essentially just commitments on the final order of transactions, but are backed by heavy financial guarantees and are quickly determined once issued. This is also covered by proof of fraud (as described in the introduction). The actual hard certainty is achieved after all trade data has been published to the base layer (meaning L1 actually achieves faster certainty). This depends on whether Rollup uses fraudulent proofs or zero-knowledge proofs in its proof of sovereignty verification - this happens on Rollup. The reason you want to do this separation is to remove the huge bottleneck of state transitions from the collator. In contrast, Rollup nodes only handle nodes that are valid for them (which means we have to add conditional transactions, proof of state, or light node validation to achieve proper interoperability). Hard certainty still depends on the base layer (but this can be up to 15 seconds on Celestia, and is also determined under Tendermint), which is what we found in Rollup  Provides a relatively fast hard certainty guarantee.


Use zero-knowledge proofs within the network to optimize validation, transaction size (e.g. only publish state differences -- but this does increase a higher degree of trust until ZKP is published). As mentioned earlier, these states prove to be useful for chains/rollups that allow connections to have easier and faster interoperability (no waiting for challenge Windows).


One downside to these conditional deals is that they are likely to be more expensive, require higher validation and release costs (such as the cost of Tendermint bulk validation, which is subsidized on the Cosmos chain), and add some latency to the system (but still much faster than an isolated Rollup). The atomicity of vertical shared integration can compensate for these problems.


During the boot phase of a new Rollup, it makes a lot of sense to use a shared collator set, and the advantages you gain as a vendor will likely outweigh some of the trade-offs you may be "forced" to make at the moat level. However, for an established Rollup, where there is a lot of trading and economic activity, giving up part of the moat may well make no sense.


This raises the question of whether we need a similar economy/transaction (per Rollup) weighted reallocation of extracted MEVs to entice already mature rollups to join the shared set -- or even to keep extremely mature rollups from generating their own networks. It's all fairly theoretical, but it's no doubt an interesting thought process involving the question of how MEVs would be presented in shared vertical worlds between many rollups with varying degrees of activity. For example, if a unique Rollup that drives value shares a portion of these profits with others through a collator set (which may not bring much "value"), then there must be more reason for them to move to their own isolated system. EigenLayr's Sreeram has it in that regard, tooSome ideas, we also recommend reading.


This becomes increasingly important given the considerable technical cost to searchers to develop new chains, so providing some sovereignty in terms of standardization and MEVs over "them" might be a good place to start. In practice, in a MEV, the dominant interface (or software) may win, but it is actually very difficult to monetize that software by running critical parts of the infrastructure (resulting in centralization). At the market level, shared collators basically provide a common pool of memory for multiple vendors with a centralized auction, which could lead to healthier competition.


One of the concerns here is that if two Are running collators in A shared cluster, then a Rollup (A) with "less economic" value may be selected to propose a block with a high amount of MEV + fees from Rollup (B). From Rollup  From B's point of view, they would essentially miss out on some value that, in the isolation approach, they would retain for themselves.


Address interoperability tradeoffs


Another note on the tradeoffs presented by interoperability, and an alternative approach to some of the problems, is as follows:


The purpose of a shared sorter network is to provide a normative guarantee for multiple chains, which is obviously a big advantage in this case. This can be combined with a mechanism to ensure that the Rollup  To make a valid state transition. This can be based on the committee's method (PoS, for example), guaranteed proof (Optimistic method), or our preferred one - ZKP, supported by the committee's signature. Because shared collators are "lazy", they only create super blocks to sort transactions from multiple rollups, leaving specific transaction execution to a particular Rollup. State proclamations (i.e., Lagrange, Axiom, or Herodotus, etc.) are all possible solutions for potentially obtaining final proclamations of cross-sovereignty Rollup. You can even add proof of economic assurance certainty by things like pledge pools, EigenLayr, etc. The basic idea is that the shared sorter provides an economic guarantee of orderliness, and the validity of the generation from this sort proves to be decisive. The basic idea is that Rollup can execute transactions synchronously between each other. For example, two Rollup node networks can conditionally know that two Rollup histories are valid, via ZKP and available data (data published to efficient DA layer). The Rollup node can settle two rollups at the same time by publishing A single Rollup block prefix from both networks A and B. It is important to point out that conditional cross-rollup transactions consume resources from two separate systems through shared execution, so cross-rollup atomic (or synchronous) transactions are likely to be more expensive than single intra-rollup transactions.


Succinct also featured cross-chain "atomic" transactions inside the Optimism Hyperchain ecosystem between rollups with shared collators (and shared fraud validators), which can be accessed insidehereCheck. Furthermore, as Polymer's Bo Du says: "Interchain atomic transactions are like getting locks between database shards while writing".


The Future of Vertical Integration


Jon Charbonneau et al have explored the possible inner workings of SUAVE chains in depth, so we won't go into too much detail. If you want a more detailed description, check out his article. That said, we think vertical integration really deserves a separate introduction, both to highlight how modular we can be (and why) and to address some of the issues and concerns associated with vertical integration.


While the current shared collator scheme for Astria, Espresso, and Radius is very modular, the collator still acts as the builder and blocker (although in the case of Astria, they do not perform transactions). Astria was also active in incorporating PBS into its structure from the beginning.


If PBS is not built into the protocol, there are several ways to implement PBS (albeit with varying degrees of decentralization). Products such as SUAVE use off-line models such as MEV-Boost, or implement builder modules such as the Cosmos SDK module built by Mekatek and Skip.


It is important to note that none of these methods are mutually exclusive. You have the flexibility to use several different methods and let anyone express their preference. That way, you can have executives competing to fill those gaps. Adding more selectivity is always good (and in keeping with our belief in modularity). However, different implementations will have different trade-offs. For example, in a case like SUAVE, you can add privacy protections via SGX or Crypto technology and add Crypto economic security to the truth, rather than relying on a fully trusted centralized PBS builder. (Thanks to Jon Charbonneau for feedback here).


Vertical integration into the builder chain ensures fairness without cutting corners, adding latency and slowing performance. Therefore, the builder chain needs to be highly optimized and may require expensive and powerful hardware (resulting in centralization). This means that to get end-user validation, we might need some kind of light node (although they must trust full nodes), or utilize a proof-of-state type setup to ensure that the chain and users have proof that bid preferences have been populated, and that the blocks have been built correctly.


Chains like this may be very state oriented (we want to avoid this), although these state-heavy transactions will be bid preferentially via smart contracts. In the case of a preferred bid, it either gets filled or it doesn't (in a very short period of time) because bids are usually only valid for a short period of time, depending on preference. This means that we may be able to implement very effective (and early) status expiration for bids -- which will allow us to trim the data and keep the chain "clean." This expiration date needs to be long enough to still allow the bid to fill first, but lowering it too much makes it nearly impossible to realize forward block space futures. We do not need to update and retrieve expired bid contracts because they do not need to be permanent (unlike applications) - this can be made more "secure" and trusted by providing state/storage proof when the bid is populated or by DAS storage solutions such as the one proposed by Joachim Neu.


As mentioned earlier, the need to verify SUAVE's "authenticity" is likely limited to the platform's "big sharks" (power users), since most SUAVE users and customers can benefit financially from it. This might prompt us to only let people run full nodes if they want to verify -- though that rules out the vast majority (you could say they don't need to verify). This is (in our opinion) in contrast to Crypto, where we would prefer to implement "trust-free" SUAVE validation through state proof-of-state or light client-friendly implementations.


The reason you need to do this is because you want to verify that your bid priority is properly padded and that the block is padded with the correct information at the time of payment (to avoid rebundling and other bugs). This is essentially a predictor problem -- in fact it can be solved by state proof (as it is with all SUAVE). However, the other problem with these state proofs across the chain is how to relay this information across the chain in such a way that it is not tampered with or concealed. This may require the adoption of a strong economic final confirmation (such as the one proposed by Lagrange), in which case you can use EigenLayr's repledge verifier to prove the certainty and authenticity of the chain, with very strong economic binding. This then brings up another problem (e.g. the bid contract states that the "predictor" -- in this case the repledgeer -- has specified the Token of the pledge and provided the economic binding force -- but how do we forfeit this outside the consensus? While you can write forfeiture criteria, this is not within the consensus, which means that social forfeiture will be exploited via smart contracts (which is almost never "fair" and can cause problems). This is one of the bigger problems EigenLayr currently has with forfeiture.


So where does this leave us? It's likely that Suave-like chains may need their own consensus algorithms and Crypto economic security to prove bid preferences and build block certainty before we get to the "de-trusting" forfeitureon chains outside of consensus -- however, that means adding more Crypto economic attack vectors, Especially if the Rollup value of its building blocks is much higher than its own Crypto economic security.


In addition, there is a lot of room for design in Suave-type chains and cross-domain MEVs. Here are some possible lines of research:


· Intent matching and intent-based systems

· Convex optimization in multi-asset trading

· DSL

· MEV reallocation

· Delay the war

· Scaling problems that have a single set of participants but need to be built for multiple Rollup state institutions

· Preference expression


Regarding preference expression, to interact with a smart contract in an EVM, you need to send a contract call (message) to a specific function at the address of the deployed code that contains the execution instructions. While the user provides input, they may not control the output due to possible stateful.


In contrast, preference expression design systems (such as SUAVE and Anoma) only require the user to sign the preference with a margin, which is paid to the builder and blocker if the searcher's preference is satisfied. For complex combinatorial logic, such as transaction sequences for MEV searchers and builders, different languages and virtual machines may need to be implemented. This is a new design space that has been getting a lot of attention lately, especially with the Anoma architecture. In the meantime, we highly recommend itThis short passage.


Original 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