The Crossing is the unit of trading in Privium. Whenever it holds something to settle, as often as once every slots, the Coprocessor takes the sealed Intents it holds, nets them pair by pair at the oracle mid, fills opposing size inside the Pool, and sends only what is left, the Residual, to public liquidity as one swap per pair. This chapter defines that procedure precisely and proves what it guarantees: netting is maximal, allocation within a batch is independent of arrival time and immune to splitting, every fill respects its limit, pairs settle independently and in any order, and the value a searcher can extract from a Crossing is bounded by the Residual alone. It closes with an expected-cost inequality that tells a trader when a Crossing beats a direct swap, and a worked example. The cryptography that seals Intents is in Chapter 3, the Ledger the Crossing writes into is in Chapter 4, and the on-chain instructions that execute the Residual and the Commit are in Chapter 9.
The batch model
Time on Solana is measured in slots. Let be the slot in which Commit landed. Crossing closes at its cutoff slot , the slot at which the Coprocessor begins it, never sooner than one batch interval after that Commit:
The Coprocessor begins a Crossing only when it has something to settle; Chapter 10 lists what counts. While work waits, Crossing begins as soon as the bound allows, . After an idle stretch, is the slot at which the Coprocessor finds work, or 750 slots after for a heartbeat, a Crossing that settles nothing and keeps the Ledger anchored (Chapter 10). Crossing owns the half-open slot interval
An Intent that the Coprocessor has received and decrypted before is a candidate for Crossing ; one that arrives later waits for Crossing , which begins as soon as slots have passed since Commit . The batch interval is a design parameter: slots (parameter), one leader span, since Solana assigns each leader four consecutive slots and keeps that span fixed across the reduction of slot duration [8]; Chapter 9 gives the slot time in force. Consecutive cutoffs therefore lie at least one leader span apart, and a Crossing produces at most one Residual per pair per leader.
The batch model is the frequent batch auction of Budish, Cramton and Shim [1], who show that in continuous limit order books a public signal creates a race in which the fastest participant picks off stale quotes, and that discretizing time into short uniform-price batches turns that race into competition on price. Privium adopts the same discretization and goes one step further on information: inside the interval every Intent is a ciphertext to everyone except the enclave (Chapter 5), so no participant, fast or slow, can condition on another’s order.
Definition 7.1 (Eligible set). For pair and Crossing , an Intent is eligible if (i) it was decrypted before , (ii) , (iii) its nonce has not been consumed by an earlier Crossing (Chapter 4 fixes the nonce discipline), and (iv) it is funded: the trader’s committed balance covers the worst case of the order,
where is the trader’s unreserved balance defined in the section on multi-pair consistency. The eligible set is . A market order is an Intent whose limit is the SDK’s protective bound rather than an unbounded value, so (7.1) is always finite.
Clearing at the oracle mid
Each pair clears at a single price taken from the oracle, not discovered from the batch:
where is the Pyth aggregate price of in as open_crossing reads it after the cutoff slot , from the price accounts Pyth keeps current on Solana (Chapter 10). Pyth publishes a confidence interval with every price and recommends that integrators pause price-dependent activity when exceeds a threshold and reject stale updates [7]. Privium applies both rules: a pair crosses in Crossing only if its prices were published within the maximum price age that Chapter 10 sets for open_crossing and
with bps (parameter): wide enough to admit normal markets in liquid pairs, tight enough that a cross at the mid is never further from a fair price than the interval Pyth itself publishes. The enclave holds the mid to the same width against a live market price. With the ratio of Jupiter’s current USD prices for and , read through the host after the cutoff (Chapter 10), the pair crosses only if
The reference decides only whether the pair trades; a pair that passes still clears at (7.2). A pair that fails the age bound, (7.3) or this band does not trade in Crossing : none of it crosses or routes, and its eligible Intents rest until the next Crossing.
Why the mid and not a price discovered from the batch? A uniform-price auction over the batch’s own orders would let the batch’s composition set the price, and a thin batch would clear far from the market. The mid is the one price at which neither side of a cross is favored: each side saves exactly the half-spread it would have paid to a market maker. Brokers that internalize client flow fill it at or inside the prevailing quote, and Easley, Kiefer and O’Hara show that flow internalized this way carries different information from flow sent to the exchange [5]; fixing the price at the mid gives both sides of an internal cross the same improvement. It also leaves the enclave no discretion. The clearing price is a public input, read from a public feed at a public slot, so any observer can recompute it.
Definition 7.2 (Active sets). With , the active buyers and sellers are
Write and for active buy and sell size. The crossed volume, the Residual and the active gross volume are
The heavy side is the side with the larger total ( if , if ); the other is the light side. The crossing rate is , the fraction of active gross size that never reaches the market. The identity follows from (7.4) and is used repeatedly below.
Theorem 7.1 (Maximal netting). Let a feasible internal allocation be a vector with for active Intents, for inactive ones, and base conservation . Then the maximal crossed volume over all feasible allocations is , and every maximal allocation fills the light side in full.
Proof. For any feasible allocation, and , and the two sums are equal, so the crossed volume is at most . The bound is attained: fill the light side in full, which uses exactly , and distribute over the heavy side, which is possible since the heavy side’s total is at least . If an allocation attains and some light-side Intent has , then the light side’s sum is strictly below its total, which is , a contradiction.
Allocation within a batch
Theorem 7.1 fixes the light side completely. The heavy side holds claims with total , against a crossed volume that must be divided among them. This is a claims problem in the sense of the axiomatic rationing literature [9], and two rules are natural: time priority, which fills claims in order of arrival until is exhausted, and pro rata, which fills every claim in proportion
Privium allocates pro rata. Two properties decide it.
Theorem 7.2 (Arrival-time invariance). Under pro rata (7.5), the fill of an Intent in Crossing is a function of the eligible set alone and does not depend on the order or slot at which Intents arrived within . Under time priority, whenever there exist two heavy-side Intents for which arriving earlier strictly increases fill.
Proof. The right side of (7.5) depends only on , and , which are functions of the eligible set, so permuting arrivals within leaves every unchanged. For time priority, order heavy-side Intents by arrival and let be the first whose cumulative size exceeds ; such a exists since . If is the first Intent, it is partially filled while any later Intent receives nothing, and moving that later Intent ahead of gives it a positive fill. Otherwise the Intent immediately before is filled in full and is not, and swapping the two strictly increases ‘s fill.
Theorem 7.2 is the in-batch form of the argument in [1]: time priority inside a batch rebuilds the speed race the batch was introduced to remove. Under pro rata there is nothing to gain from latency inside , and the only timing that matters is whether an Intent makes the cutoff at all.
Theorem 7.3 (Split and merge neutrality). Under pro rata, if a trader replaces an Intent of size by Intents of sizes with and identical other fields, the total fill of the pieces equals the fill of the original. Conversely, merging Intents does not change their total fill.
Proof. The heavy-side total and the crossed volume are unchanged by the replacement, since both are sums over sizes. The pieces receive , the fill of the original. Every other Intent’s fill is unchanged for the same reason. Merging is the same identity read backwards.
The converse also holds in the continuous model: the proportional rule is the only rule on claims problems that is immune to both merging and splitting of claims [9], so pro rata is not one fair choice among several but the unique rule with this property.
Integer fills
Sizes are integers in base units, and (7.5) is generally fractional. Privium rounds by the largest-remainder method. Let , let , and let . The Intents with the largest receive one more base unit. Ties are broken by , where is a 32-byte seed the enclave draws at the cutoff and includes in the Commit.
Lemma 7.4 (Rounding). The rounded allocation satisfies exactly, for every , and no trader can bias the tie-break by choice of nonce.
Proof. Since , we have . Each , so is at most the number of Intents with , and adding one unit to of them yields the exact total. Each fill is either the floor or the floor plus one of a value whose fractional part is positive whenever the unit is added, which gives the bound. The seed is drawn after every eligible nonce is fixed, so the tie-break order is independent of each nonce from the trader’s view, and its effect is at most one base unit.
The listing below is the Coprocessor’s per-pair kernel. It takes no clock and no arrival order, which is Theorem 7.2 in code; route eligibility is applied afterwards.
pub struct OpenIntent { pub id: IntentId, pub side: Side, pub size: u64, pub limit: Price, pub nonce: [u8; 16] }
pub struct PairCross { pub fills: Vec<(IntentId, u64)>, pub crossed: u64, pub residual: i128 }
pub fn cross_pair(eligible: &[OpenIntent], mid: Price, seed: &[u8; 32]) -> PairCross {
let active = |i: &&OpenIntent| match i.side {
Side::Buy => i.limit >= mid,
Side::Sell => i.limit <= mid,
};
let (buys, sells): (Vec<&OpenIntent>, Vec<&OpenIntent>) =
eligible.iter().filter(active).partition(|i| i.side == Side::Buy);
let q_buy: u128 = buys.iter().map(|i| i.size as u128).sum();
let q_sell: u128 = sells.iter().map(|i| i.size as u128).sum();
let crossed = q_buy.min(q_sell);
let (light, heavy, q_heavy) =
if q_buy >= q_sell { (sells, buys, q_buy) } else { (buys, sells, q_sell) };
// Light side fills in full (Theorem 7.1).
let mut fills: Vec<(IntentId, u64)> = light.iter().map(|i| (i.id, i.size)).collect();
if q_heavy == 0 {
return PairCross { fills, crossed: 0, residual: 0 };
}
// Heavy side: pro rata with largest remainder (Lemma 7.4).
let mut rows: Vec<(IntentId, u128, u128, [u8; 32])> = heavy
.iter()
.map(|i| {
let num = crossed * i.size as u128;
(i.id, num / q_heavy, num % q_heavy, tie_key(seed, &i.nonce))
})
.collect();
let floor_sum: u128 = rows.iter().map(|r| r.1).sum();
let mut left = crossed - floor_sum;
rows.sort_by(|a, b| b.2.cmp(&a.2).then(a.3.cmp(&b.3)));
for row in rows.iter_mut() {
if left == 0 { break; }
row.1 += 1;
left -= 1;
}
fills.extend(rows.into_iter().map(|r| (r.0, r.1 as u64)));
PairCross { fills, crossed: crossed as u64, residual: q_buy as i128 - q_sell as i128 }
}
fn tie_key(seed: &[u8; 32], nonce: &[u8; 16]) -> [u8; 32] {
let mut h = Sha256::new();
h.update(seed);
h.update(nonce);
h.finalize().into()
}
Routing the Residual
After crossing, each heavy-side Intent has an uncrossed remainder . That remainder can reach public liquidity only at a price worse than the mid, so it is routed only if the trader’s limit tolerates the worst price the route may produce.
Definition 7.3 (Route eligibility and the slippage bound). For each pair with , the Coprocessor obtains a quote for the Residual direction from Jupiter and sets a slippage bound from it, with floor bps (parameter), the default tolerance used in Jupiter’s own quote examples [6]. The worst admissible prices are for a buy Residual and for a sell Residual. A heavy-side remainder is route-eligible if (buy) or (sell). The routed size is
and a remainder that is not route-eligible rests, unfilled, for the next Crossing until its expiry .
Jupiter’s Swap API V2 returns, with every route, the expected output and an otherAmountThreshold, the minimum output after applying the requested slippageBps; its Router path /swap/v2/build returns raw swap instructions routed by the Metis engine across Solana DEXs, for a program to compose into its own transaction [6]. Privium uses the exact-input form in both directions, so the Pool always knows what it spends:
- Sell Residual. Input base units of ; minimum output in .
- Buy Residual. Input in ; minimum output base units of .
In the buy case the Pool spends the mid value of the Residual and receives slightly less base than ; routed buyers share the received base pro rata to their routed remainders and the shortfall rests or expires with them. Both cases realize an average price inside .
The enclave signs the bound with as a structured message under the domain tag privium/route/v1, and the Pool’s Residual instruction executes the Jupiter route and then checks the vault deltas, not the route’s own claims:
#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct ResidualOrder {
pub crossing: u64, // k
pub pair: [Pubkey; 2], // (a, q)
pub input_mint: Pubkey,
pub amount_in: u64, // A_in
pub min_out: u64, // lower bound on A_out
pub deadline_slot: u64, // t^(k) + Delta
pub route_hash: [u8; 32], // H(Jupiter id | data | accounts), Chapter 9
}
pub fn settle_residual_bounds(
order: &ResidualOrder,
in_before: u64, in_after: u64,
out_before: u64, out_after: u64,
slot: u64,
) -> Result<(u64, u64)> {
require!(slot <= order.deadline_slot, PriviumError::ResidualExpired);
let spent = in_before.checked_sub(in_after).ok_or(PriviumError::VaultUnderflow)?;
let got = out_after.checked_sub(out_before).ok_or(PriviumError::VaultUnderflow)?;
require!(spent <= order.amount_in, PriviumError::OverSpend);
require!(got >= order.min_out, PriviumError::SlippageBound);
Ok((spent, got)) // recorded in CrossingState as this Crossing's fill
}
The signature check on ResidualOrder uses the ed25519 instruction-introspection pattern of Chapter 9. Because the check reads balances of Pool-owned vaults before and after the CPI, its guarantee does not depend on which DEXs the route touches.
The Commit that follows posts the new Ledger root computed from the crossed fills and the recorded vault deltas. Chapter 4 proves the conservation invariant over that root; the Crossing’s contribution is the following local identity.
Lemma 7.5 (Crossing balance). In Crossing , for pair with fee rate , the crossed fills move exactly base units from sellers to buyers and quote units (before fees) from buyers to sellers; fees move from each side out of the Ledger, and the Commit pays the Crossing’s total from the quote vault to the fee recipient (Chapter 9); the routed fills move exactly the recorded deltas between routed traders and the vaults. Hence the Crossing changes by zero for the base asset and by zero for the quote asset once the fee is paid, which is the balance condition (4.4) of Chapter 4.
Proof. Each crossed unit is debited from one Ledger entry and credited to another, so the vaults do not move and the sum of entries is unchanged except for the fee, which leaves the entries and the quote vault by the same amount when the Commit pays it out. Each routed unit moves between the vaults and the market, and the routed traders’ entries change by exactly the recorded vault deltas, distributed pro rata, so entries and vaults change together.
Theorem 7.6 (Limit safety). Every fill produced by a Crossing executes at a price no worse than its Intent’s limit.
Proof. Crossed fills execute at , and only active Intents cross, for which (buy) or (sell). A routed buyer pays shared pro rata for at least shared in the same proportion, so its average price is at most , which rounds to up to one base unit by route eligibility; the vault check in settle_residual_bounds makes any execution outside the bound revert. The sell case is symmetric with . A trader whose fill is both crossed and routed pays a volume-weighted average of two prices each within its limit, which is within its limit.
Price improvement versus routing
The question a trader asks is whether a Crossing is cheaper than the same trade sent straight to an aggregator. We answer it with a cost model that is standard for automated market makers and state the answer as an inequality.
Model. Measure every cost against the mid , in quote units. A direct trade of signed base size through public liquidity pays three components: a per-unit fee (DEX fees along the route), a per-unit half-spread (the distance between the mid and the best executable marginal price), and price impact. For impact we use the property that makes constant-function market makers tractable: their state after a sequence of swaps depends only on the net flow, so the total quote paid by a sequence of trades in one pool is a function of their sum [10]. Write for the total impact cost, relative to the marginal price, of net flow , with and convex. A batch of direct trades executed in any order within one interval then costs, in aggregate,
The same Intents through a Crossing, where the Pool pays the protocol fee on crossed and routed notional (the fee itself belongs to Chapter 12), cost
taking every active remainder as route-eligible so that both sides execute the same quantities.
Theorem 7.7 (Expected-cost inequality). Under the model, for a batch if and only if
where is the crossing rate. In expectation over batch composition, the Crossing is cheaper in aggregate if and only if .
Proof. In the direct case and , since the direct trades are the active Intents themselves. Substituting into (7.7) and subtracting (7.8), the impact terms cancel and
using and . The sign is that of . The expectation statement follows by linearity of applied to the same difference.
Two features of (7.9) matter. First, impact cancels: aggregation neither creates nor removes impact for path-independent liquidity, so the entire advantage of crossing is the fee and spread that crossed units never pay, and it scales with the crossing rate. Second, (7.9) is a statement about aggregate cost, and it is distributed unevenly in a way that favors the light side.
Corollary 7.8 (Light side). A light-side trader of size is filled in full at the mid and pays , against to trade alone. The Crossing is cheaper for that trader whenever , which (7.9) implies for every .
Proof. Theorem 7.1 fills the light side in full at . The standalone cost is (7.7) with one trade. The implication holds since .
A heavy-side trader receives fraction at the mid and the rest inside the Residual, sharing the Residual’s impact per unit. That trader’s comparison depends on how its own size relates to the Residual, which is why the aggregate statement is the right object: under (7.9) the batch as a whole pays less than its members would have paid, and the light side’s saving is guaranteed. How the crossing rate grows with flow, and what that does to the cost curve over time, is the subject of Chapter 12.
Multi-pair consistency
Every pair in Privium is quoted in , and a trader may hold Intents in several pairs in the same Crossing. Two consistency properties are needed: the outcome must not depend on the order in which the enclave processes pairs, and internal prices must admit no cycle that extracts value from the Pool.
Definition 7.4 (Reservation). At the start of Crossing , for each trader the enclave reserves, in the order of the Intents’ hashes, the worst-case debit (7.1) of each eligible Intent against . An Intent whose reservation does not fit in the remaining unreserved balance is ineligible for this Crossing. Proceeds of a Crossing are credited after all pairs settle and become reservable in Crossing , whose cutoff falls at least slots after Commit .
Theorem 7.9 (Pair independence). With reservations, the per-pair outcomes of Crossing are independent of the order in which pairs are processed, may be computed in parallel, and leave every balance .
Proof. The eligible set of each pair is fixed by Definition 7.4 before any pair is processed, and the per-pair kernel reads only its own eligible set, the mid of its own pair and the seed. No pair’s output is an input to another’s, so the outcome is a product of independent maps and is order-invariant. For nonnegativity, each Intent’s actual debit is bounded by its reservation: a crossed or routed buy pays at most per unit by Theorem 7.6, and a sell gives at most . The reservations of one trader sum to at most the trader’s committed balance in each asset, so total debits do not exceed , and credits are nonnegative.
Proposition 7.10 (No internal cycle). Any sequence of crossed fills within one Crossing that starts and ends in the same asset returns at most the starting quantity.
Proof. Every crossed fill exchanges an asset against at that pair’s mid, less fees. A cycle multiplies the quantity by times a product of factors , and the product of mid ratios around a cycle telescopes to 1.
Each pair’s Residual is a separate swap, and all of them touch the vault. On Solana a transaction declares the accounts it writes, and transactions writing the same account are serialized [2]; Chapter 9 gives the write-lock layout that lets Residuals in different pairs land in one leader span.
MEV: batched Residuals versus individual swaps
A public swap reveals its size, direction and slippage tolerance before it executes, and a searcher who can order transactions around it extracts value by front-running and back-running it. Daian et al. documented this on Ethereum [3], and Zhou et al. formalized the sandwich attack against constant-product pools and showed that the attacker’s optimal profit is bounded by the victim’s slippage tolerance [4]. We use that bound as the adversary model.
Definition 7.5 (Sandwich adversary). For a swap of size with slippage tolerance , a sandwich adversary chooses a front-run and back-run around it. The victim’s execution degrades by at most what its bound allows, so the value transferred from victim to adversary is at most plus impact the victim would have paid anyway.
Theorem 7.11 (Extraction bound). Let a batch of active Intents with gross size and Residual be executed either individually, each with tolerance , or through a Crossing with Residual bound . The maximal value a sandwich adversary can extract is at most in the first case and at most in the second.
Proof. Individually, each swap exposes at most by Definition 7.5, and the bound sums to . Through a Crossing, crossed units never enter a public transaction: they are Ledger updates inside the enclave, committed as ciphertext (Chapter 4), so they offer no execution to degrade. The only public swap is the Residual, whose realized price is enforced on chain by the vault check, so its exposure is at most . The identity follows from (7.4).
The theorem understates the difference in two ways. First, the Residual’s bound is set per Crossing from a fresh quote with a floor of , while individual traders often send loose tolerances. Second, a sandwich needs a target worth the cost of the attack, and the Residual reveals only a net figure per pair per Crossing: no wallet, no trader history, nothing a searcher can model as one participant’s next move. What the Residual does reveal, and how little it says about any trader, is analyzed in Chapter 8.
Adverse selection at the mid
In a continuous market a fast trader who sees the price move hits a quote that has not yet moved. A Crossing offers no such quote: the batch is sealed before open_crossing reads the mid, and the pair crosses only while that mid lies within of a market price read after the seal.
Proposition 7.12 (No pick-off at the mid). Let every eligible Intent be sealed before , and let be a positive martingale with respect to a filtration that contains a trader’s information, with the reference read at a slot as . Let the cross execute at only on the event , with known by , and let an Intent that does not cross gain nothing at the mid. For any Intent whose side and size are -measurable with , the expected per-unit gain relative to the cross price, marked at any slot , is at most in absolute value. The rest of the counterparty’s per-unit exposure is the increment , whose root mean square does not depend on .
Proof. The gain per unit is . The event is -measurable and is -measurable with , so the tower property gives . On the second term is at most in absolute value, so its conditional expectation is at most in absolute value. The first term is an increment of the martingale after and is independent of when the Intent was formed.
The seal before the read, with the band at , is what removes the speed race: knowing the mid before the cutoff is worth at most a fraction of the price per unit, in expectation. What remains is symmetric price variance over the interval until the fill is marked, the quantity Budish et al. identify as the residual cost of a frequent batch [1].
Worked example
This is an example with illustrative inputs; none of its figures are measurements or market data.
One pair, SOL/USDC, in Crossing . Mid USDC, confidence within (7.3), slippage bound bps from the quote. Eligible Intents:
| Intent | Side | Size (SOL) | Limit (USDC) | Active at mid |
|---|---|---|---|---|
| A | buy | 60 | 151.00 | yes |
| B | buy | 30 | 150.50 | yes |
| C | buy | 10 | 149.00 | no () |
| D | sell | 40 | 149.50 | yes |
| E | sell | 20 | 145.00 | yes |
Active sizes: , , so , , and . Sellers D and E are the light side and cross in full at 150.00, receiving 9,000 USDC before fees. Buyers share 60 SOL pro rata by (7.5): A receives and B receives , each at 150.00.
Remainders are A: 20 and B: 10. The buy-side worst price is . A’s limit 151.00 clears it; B’s limit 150.50 does not, so B’s remainder rests for the next Crossing. The routed size is . The Residual spends USDC with minimum output , about 19.9005 SOL. Suppose (illustrative) the route returns 19.94 SOL, a realized price of , inside the bound.
Outcome before fees: A holds SOL for 9,000 USDC, an average of about 150.15, under its limit by Theorem 7.6; the 0.06 SOL shortfall rests with A’s Intent. B holds 20 SOL at 150.00 with 10 resting. C rests untouched. D and E sold in full at the mid. Of 150 SOL of active gross size, 20 reached a public pool. By (7.9), the batch is cheaper than five direct swaps whenever , and by Theorem 7.11 a sandwich adversary faces at most of the exposure the five swaps would have offered.
References
- E. Budish, P. Cramton, J. Shim, “The High-Frequency Trading Arms Race: Frequent Batch Auctions as a Market Design Response”, Quarterly Journal of Economics 130(4), 2015. https://doi.org/10.1093/qje/qjv027
- N. Lokhande et al., “Encifher: A Trusted-Execution Coprocessor for Confidential Computation on Solana”, IACR ePrint 2026/1504, July 2026. https://eprint.iacr.org/2026/1504
- P. Daian et al., “Flash Boys 2.0: Frontrunning in Decentralized Exchanges, Miner Extractable Value, and Consensus Instability”, IEEE Symposium on Security and Privacy, 2020. https://arxiv.org/abs/1904.05234
- L. Zhou, K. Qin, C. F. Torres, D. V. Le, A. Gervais, “High-Frequency Trading on Decentralized On-Chain Exchanges”, IEEE Symposium on Security and Privacy, 2021. https://arxiv.org/abs/2009.14021
- D. Easley, N. M. Kiefer, M. O’Hara, “Cream-Skimming or Profit-Sharing? The Curious Role of Purchased Order Flow”, Journal of Finance 51(3), 1996. https://doi.org/10.1111/j.1540-6261.1996.tb02706.x
- “Swap API” (Metis quote,
otherAmountThreshold,slippageBps; Swap V2/build), Jupiter Developer Docs, checked 2026-11-16. https://developers.jup.ag/docs/swap-api - “Best Practices” (confidence intervals and staleness), Pyth Network Docs, checked 2026-11-16. https://docs.pyth.network/price-feeds/best-practices
- “Reduced Slot Times”, Solana Foundation, 2026. https://solana.com/upgrades/reduced-slot-times
- W. Thomson, “Axiomatic and Game-Theoretic Analysis of Bankruptcy and Taxation Problems: A Survey”, Mathematical Social Sciences 45(3), 2003. https://doi.org/10.1016/S0165-4896(02)00070-7
- G. Angeris, H.-T. Kao, R. Chiang, C. Noyes, T. Chitra, “An Analysis of Uniswap Markets”, Cryptoeconomic Systems, 2021. https://arxiv.org/abs/1911.03380