Director of Operations at Hats.Finance, a decentral platform for Audit Competitions and Bug Bounties. 

My honest opinion, regardless of politics and based on what code / research exists, is they’d both do better if they actually shared ideas in the same language; but there is no lingua fraca (part of the reason I’ve been trying to formalize some Solana mechanics)

One of the most interesting things that those in Ethereum can learn about from Solana is Jito's MEV auction; here are some high level differences:

1. # of auctions isn't fixed per slot; dynamically changes based on txns 
2. Set of auctions implicitly defines a DAG of state priority
3. Often more efficient than PBS (!)

ヽ(⌐■_■)ノ♪♬ @ @gauntlet/🤖Ventures/tldr/Aera \\ ¯\_(ツ)_/¯ Struggling with the nature of randomness \\ main: @gaa \\ /red-bull /defi-research maxi

Note that the number of auctions depends on the particular state (= Uniswap reserves at program address X) that is touched — if there were only 2 different pools interacted with, then there are only two auctions 

tl;dr you only _know_ the number of PBS style auctions you run _conditional_ on a set of bundles!

Why do dynamic auctions?
A. Parallelism: if state is disjoint, auctions can be run in parallel)
B. Streaming: Allow transactions to be streamed directly to proposers rather than need to be collected and batched in a mempool — when a new transaction arrives and touches new state, a new auction is started

C. Lower bid sniping: Different auctions are independent — 'reserve price' is lower as competition is partitioned vs. everyone competing for the same item in a PBS-style single item auction — like a combinatorial clock auction (c.f. Ausubel https://www.ausubel.com/auction-papers/practical-guide-to-the-cca.pdf)

Mathematically, these three things give you _very_ different queueing behavior

A single item auction (e.g. PBS) tends to have a classic M/M/1 queue behavior (assuming rational + random bidders) — there's a single auction and it has some notion of probabilistic arrivals

Mathematically, these three things give you _very_ different queueing behavior

A single item auction (e.g. PBS) tends to have a classic M/M/1 queue behavior (assuming rational + random bidders) — there's a single auction and it has some notion of probabilistic arrivals

https://en.wikipedia.org/wiki/M/M/1_queue

On the other hand, the Jito style auction has an arrival process that looks more like the Chinese Restaurant Process — a probabilistic process where a 'customer' (txn) arrives and joins an existing auction with some probability or starts a new auction ("joins an empty table") with some probability

The Chinese Restaurant Process style of queuing (which is a Dirichlet process) can be more efficient than the M/M/1 depending on the particular parameters (e.g. probability of joining an existing table = probability of multiple txns touching the same state)

2. Set of auctions implicitly defines a DAG of state priority

A simple (but not completely correct) way of viewing the Solana scheduler is as doing the following:
1. Take a set of n transactions and bucket them into k auctions A1, ..., Ak
2. Auction Ai clears at price pi
3. Order auctions by pi to get final ordering

This would work if there were no contention across state accesses — but, of course, there is in practice; gedanken:

Suppose one does arbitrage btw 2 Uniswap pools — I submit a bundle that has to be a part of 2 auctions (1 for each pool). If I win 1 auction but not the other, how should I expect to be ordered?

IRL, the scheduling algorithm stores a DAG of transactions, assigning a transaction to a particular auction based on the relative bids between transactions in a bundle

Such an algorithm cannot always perfectly schedule things (c.f. 9 Queens Problem in Chess) and only 'approximately' partitions txns into auctions Ai

This implicit 'priority' between auctions gives rise to a combinatorial auction (e.g. I am bidding on any subset of state) that is highly constrained by the DAG

Research Question 1: What constraints on this auction lead to efficient bidding (e.g. an MEV searcher can 'easily' find a optimal bid to make over states?)

I'll note that, as far as I know, this diverges dramatically from the existing combinatorial auctions literature in that the dynamic nature of the auction (e.g. the number of possible bundles I can bid on changes dynamically via the constraints of the DAG) is never considered in the literature

What does this mean, practically speaking? This means that the auction is actually able to do some amount of 'learning' (in the sense of online learning) based on how it adds constraints in the DAG (via the scheduling algorithm) given new transactions — if it has low hindsight regret, it can asymptotically beat PBS

3. Often more efficient than PBS 

This naturally brings us to a question: when are Jito-style 'dynamic combinatorial auctions' better than
a. Combinatorial Auctions (e.g. online ad auctions with autobidding)
b. Single Item Auctions (PBS)

There clear exist some edge cases where its better but can those be formalized?

4. Nothing is free

There are some drawbacks to this auction model, relative to the single item auction:

1. Hard to find optimal bidding strategy: Worst case (e.g. high contention): optimal bidding strategy degrades to combinatorial FPA 
2. Spam: More susceptible to DoS on particular state changing allocations

The latter issue is being handled by updates to the scheduler and the lookahead scheduling provides some of this but as for 1...

You need a formal mechanism model to figure out what this looks like — and @ksk and I have been doing a little work on this [stay tuned™]

Let's try to dive into these features and get some heuristics for why they help

1. Dynamic auctions

The number of auctions run in a slot changes based on the transactions; for instance, if there are 6 txns going to 3 different Uniswap pools, then three auctions are implicitly run for each Uniswap pool

Yes that's easy; it's when there is contention over the same state that you create a new auction

It's not possible with Jito to create atomic transaction bundles which touch two different states?

Do you think we can use the fact that there is randomness when you contend for the same state to have some sort of order policy enforcement(basic one is disincentivize frontrun/sandwich)?

I have gathered my thoughts regarding this in this post.

Technically there is no mechanism that works since there are combinatorial lower bounds on fairness: https://arxiv.org/abs/2309.14201

But if your payoff is smooth enough (like a cfmm) then yes, you can get something like differential privacy: https://eprint.iacr.org/2021/1101.pdf

Do you think we can use the fact that there is randomness when you contend for the same state to have some sort of order policy enforcement(basic one is disincentivize frontrun/sandwich)?

I have gathered my thoughts regarding this in this post.
https://hackmd.io/@0xtrojan/bullshark_poh