Content uploaded by Aviv Yaish
Author content
All content in this area was uploaded by Aviv Yaish on Mar 03, 2025
Content may be subject to copyright.
Scheduling With Time Discounts
Yotam Gafni
Weizmann Institute
Aviv Yaish
Yale University
Abstract
We study a financial version of the online problem of scheduling weighted packets
with deadlines. The main novelty is that, while prior works assume packets have fixed
weights, we consider packets with time-decaying values. Such considerations are natural
in financial environments, where the present value of future actions may be discounted.
We analyze the competitive ratio guarantees of scheduling algorithms under a range
of discount rates encompassing the “traditional” undiscounted case where weights are
fixed (i.e., a discount rate of 1), the fully discounted “myopic” case (i.e., a rate of 0), and
those in between. We show how existing methods from the literature perform subop-
timally in the more general discounted setting. Notably, we devise a novel memoryless
deterministic algorithm, and prove that it guarantees the best possible competitive ra-
tio attainable by deterministic algorithms for discount factors up to ≈0.77. Moreover,
we develop a randomized algorithm and prove that it outperforms the best possible
deterministic algorithm, for any discount rate. While we highlight the relevance of our
framework and results to blockchain transaction scheduling in particular, our approach
and analysis techniques are general and may be of independent interest.
1 Introduction
We study an online problem where an algorithm is tasked with transmitting incoming
weighted packets with deadlines, with the goal of maximizing the total weight of pack-
ets which are delivered before their expiration. The inherent difficulty of the problem arises
when the number of packets that can be transmitted concurrently is limited and no informa-
tion about incoming packets is given in advance. This problem is considered fundamental
[45,67,69], and is widely applied to the management of communication networks [33,67],
ride sharing [2,19], and time-sensitive business decisions [70], among other settings.
Despite some of the problem’s applications’ financial motivations and their analogy be-
tween packet weight and monetary value [2,19,70], the problem’s classic model only con-
siders packets with static weights and does not capture the time value of money [29]. Im-
portantly, one may prefer to receive a fixed amount of funds sooner rather than later, as it
can be invested and thus increase in value [28]. This consideration, which can be formalized
as the discounting of future income by a factor, adds a novel dimension of complexity that a
scheduling algorithm has to face: respecting incoming packets’ “hard” deadline constraints
may not suffice to achieve optimality, because packets can change in weight even beforehand,
as dependent on the discount rate. Given this new difficulty, a natural open question arises:
Can one devise scheduling algorithms with good performance guarantees that ac-
count for the time value of money, when considering a variety of discount rates?
1
0 0.2 0.4 0.6 0.8 1
0.4
0.6
0.8
1
Discount Rate
Competitive Ratio
ROP T upper bound (Theorem 5.1)
RRDIS C lower bound (Theorem 5.3)
Deterministic upper bound (Theorem 4.1)
RℓIB upper b ound (Claim 4.5)
RℓIB lower bound (Theorem 4.3)
RGreedy tight bound (Claim 3.3)
Figure 1: Our competitive ratio bounds for the deterministic algorithms we present in
Sections 3and 4and the randomized ones we give in Section 5, for miners with a mining
ratio α= 0 and discount rates λ∈[0,1]. For comparison, the celebrated work of Veselý
et al. [71] shows that the tight bound for the undiscounted case is ϕ−1≈0.618.
1.1 Our Contributions
In our work, we provide an affirmative answer to this question by presenting two scheduling
algorithms which discount the value of future actions according to a given factor λ: the
ℓ-immediacy-biased (ℓIB) algorithm which attains the optimal deterministic performance
for any discount rate λ∈[0,≈0.77], and the randomized RDIS C algorithm which provides
guarantees beyond those given by the best possible deterministic algorithm for any λ∈[0,1].
Application to blockchains. Our time-discounted framework and the algorithms we
present can be applied to a general class of financial scheduling problems. Throughout
the paper, we explicitly adopt the terminology of one particular application: the problem
of cryptocurrency transaction scheduling. Cryptocurrencies are payment systems wherein
nodes called miners1process users’ financial transactions by allocating them to size-limited
batches called blocks. Miners face the same uncertainty as scheduling algorithms, due to their
limited knowledge of future transactions. Furthermore, miners may prefer to obtain profits
earlier rather than later, as these can be used to increase income, e.g., by depositing profits
as stake [37] or in other interest-bearing instruments [34,75,78]. Similarly, a transaction
is analogous to a packet, and can be defined according to its fee (which a miner can collect
by allocating it to a block) and its deadline, or time to live (TTL) (which is a user-defined
parameter that specifies the time window where the transaction is valid for allocation). As
Table 1shows, half of the top 10 cryptocurrencies (with respect to market capitalization as
of Jan. 23rd, 2025 [16]) support deadlines, whether by default or using third-party services.
1In some blockchains this role may be filled by actors called stakers, validators or builders; we adopt
Bitcoin’s nomenclature and use the name miners.
2
Table 1: The USD market cap and ranking (with respect to market cap) of some of the
cryptocurrencies that support transaction deadlines.
Cryptocurrency Market Cap (USD) Ranking Deadline Support
Ethereum $389 billion 23rd party (e.g., Flashbots [30])
XRP Ledger $180 billion 3Built-in [40]
Solana $121 billion 5Built-in [64]
Cardano $34 billion 9Built-in [20]
Tron $21 billion 10 Built-in [65]
Beaverbuild
35.06%
Titan
Builder
21.75%
Builders
with ≤15%
43.19%
Figure 2: The all-time block
share of Ethereum block
builders.
Beaverbuild
47.42%
Titan
Builder
42.74% Builders
with ≤15%
9.84%
Figure 3: The block share of
Ethereum block builders, for
Jan. 15 - Feb. 15, 2025.
Lido
27.77%
Coinbase
8.64%
Binance
6.64%
SSV
5.45%
Ether.Fi 5.24%
Stakers
with ≤5%
46.26%
Figure 4: The all-time block
share of the top 5Ethereum
stakers.
Some highlight the importance of temporal considerations in blockchains [35,39,74].
Consider, for example, that most Ethereum blocks are currently built by a small number
of actors, implying that a single actor may build several blocks in a row (see Figs. 2to 4).
However, prior foundational work on fee mechanisms adopts a myopic approach which does
not account for such factors [4,6,7,13,14,31,32,39,50,60,61], instead focusing on
strategic manipulations either by users (e.g., to lower their fees or increase their chances
of allocation), or by miners (e.g., to increase revenue by introducing “fake” transactions).
On the other hand, in this work, we take the opposite approach and focus on the temporal
considerations and uncertainty faced by miners when deciding which transactions to allocate
to blocks. Still, we discuss the strategic implications of our results in Appendix B.
Model. We advance a novel packet scheduling setting where future revenue is discounted,
thus expressing the time preference of miners. With every passing time step, each trans-
action’s fee “decays” by a factor λ < 1, until the transaction’s deadline passes. Another
discount factor we consider is the miner ratio α, i.e., a miner’s share of all mining power,
which determines the probability of mining future blocks. Our key benchmark to evaluate
a scheduling algorithm is its competitive ratio R[10], which we define in Definition 2.7 as
3
Table 2: A summary of our competitive ratio bounds. For the discounted case, results are
parameterized by the discount rate λand are for miners with a mining ratio α= 0. For
brevity, in some of our results we use the notation ℓ=1
2(λ+pλ2+ 4).
Result Bound
Greedy tight bound (Claim 3.3)(1 + λ)−1
Deterministic upper bound (Theorem 4.1)ℓ−1
ℓIB lower bound (Theorem 4.3)min nℓ−1,1 + λ3−1o
ℓIB upper bound (Claim 4.5)min ℓ−1,1+λℓ
1+λ+λ2ℓ+λ3,min
n≥1
Pn+1
i=0 λi
P2n
i=0 λi
Randomized upper bound (Theorem 5.1)1−λ
4
RDISC lower bound (Theorem 5.3)1−e−λλ−1
the ratio of the algorithm’s performance divided by the optimal allocation’s performance.2
Results. We now go over our main results, which we also summarize in Fig. 1and Table 2:
•Revisiting the classics. In Section 3, we analyze the classic Greedy algorithm [33], that
always allocates the highest-fee transaction (equivalently, the heaviest packet). As we
prove in Claim 3.3, its performance for some discount rates surpasses the tight bound
of the deterministic undiscounted case. The undiscounted bound equals one over the
golden ratio ( 1
ϕ≈0.618), and has only recently been matched by the celebrated work
of Veselý et al. [71]. This motivates our study of the discounted case, and, as we show,
we can even outperform Greedy in large regimes of discount rates.
•Bounds for the discounted setting. We prove upper bounds on the competitive ratios
of both deterministic algorithms (in Theorem 4.1) and randomized algorithms (in
Theorem 5.1), as dependent on the discount rate.
•A new deterministic algorithm. In Definition 4.2, we present our novel ℓ-immediacy-
biased (ℓIB) algorithm. When setting ℓcorrectly, we prove in Theorem 4.3 that
the algorithm matches our deterministic upper-bound: its performance is optimal for
0≤λ≲0.770018. We call this range of discount values the “semi-myopic” regime.
•An even better randomized algorithm. We describe our randomized RDISC algorithm
in Definition 5.2, and then lower bound its performance in Theorem 5.3. Our result
shows that for any discount rate, RDI SC has a better competitive ratio than the best
deterministic scheduling algorithm.
2This implies that R∈[0,1] and follows the classic work of Hajek [33], while other work may use the
inverse ratio, such as the elegant work of Veselý et al. [71]. Since both approaches are used by important
preceding work and only differ aesthetically (i.e., the lower bounds of the latter are the upper bounds of the
former, and vice versa), we choose the former.
4
Techniques. Due to the discounted setting, we develop novel methods to analyze the
performance of scheduling algorithms, such as our “conditional gap” technique. Intuitively,
within the set of all decisions made by an algorithm ALG, we mark the cases where it was
(locally) outperformed by the optimal algorithm OP T by over some factor ℓ. In these cases,
it must be that ALG has already allocated this transaction in a previous step. This naturally
creates “subchains” of corresponding transactions. We are able to isolate the analysis to each
subchain, and condition it on the gap (number of steps) between the subchain’s first and
second transactions. Our case analysis shows that this gap must be at least 3, which, for
example, drives the result of Theorem 4.3.
Lessons learned. We believe that there is a general lesson to be learned from our work
which can be applied to other online problems. An algorithm’s competitive ratio is generally
driven by its performance when dealing with sequences designed to trick the algorithm into
making the wrong choices. Discounting future revenue is both natural, and also assists in
withstanding adversaries by mitigating the impact of long and complex bad sequences. Thus,
when the discount is strong enough, but without going all the way to being completely my-
opic (i.e., fully discounting future utility), algorithms may guarantee optimal results. Since
discounting is an important feature of financial environments, considering the discounted
version of a problem may be a useful tool for designing practical algorithms.
Roadmap. In Section 2we detail our model. Our analysis begins with Section 3, where we
present the classic Greedy scheduling algorithm (Definition 3.1), and show that for a discount
factor of λit guarantees a tight 1
1+λcompetitive ratio (Claim 3.3). In Section 4, we analyze
the general deterministic case. There, we first prove an upper bound of 2λ+pλ2+ 4−1
for any deterministic allocation algorithm (Theorem 4.1). Then, we present our ℓIB algo-
rithm (Definition 4.2) and finish by bounding its performance from below (Theorem 4.3)
and above (Claim 4.5). In particular, we show that its performance matches the general
deterministic bound for large regimes of discount rates. We proceed to analyze randomized
algorithms in Section 5. To start, we prove a randomized upper bound of 1−λ
4(Theo-
rem 5.1). We continue by analyzing our randomized algorithm RDISC (Definition 5.2) and
show that it performs better than our deterministic upper bound for any choice of λ(The-
orem 5.3). Notably, our optimal deterministic algorithm performs very close to RDISC for
lower λfactors (see Fig. 1). We conclude with an overview of additional related work in
Section 6, and with a discussion of our results in Section 7. We provide additional content in
the appendices: missing proofs (Appendix A), a discussion of blockchain modeling in light
of relevant empirical evidence (Appendix B), and a summary of notations (Appendix C).
2 Model
Our game proceeds in T∈Nturns. At each one, a set of new transactions is broadcast to the
network by users, and a miner is chosen to create the upcoming block. The miner, assumed
to be profit-maximizing, has the sole authority to decide which transactions to allocate to
its block, among the set of valid transactions which were not allocated beforehand.
We proceed to formally define the model. All notations are summarized in Appendix C.
5
2.1 Blockchain Model
Blocks. Blocks have a predefined maximal capacity of B ∈ N∪ {∞} identically-sized
transactions. We focus on the case where B= 1.
Transactions. A transaction τ= (t, ϕ)is defined by its TTL t∈ T and fee ϕ∈Φ, where
T × Φdef
= (N∪ {∞})×R. The TTL represents a transaction’s validity period during which
it is eligible for inclusion in a block, while its fee is awarded to the first miner to allocate it
before it expires. We denote τ’s TTL and fee by t(τ), ϕ(τ), respectively.
Transaction schedule. The transactions broadcast to the network at each turn are given
by ψ:{0, . . . , T } → (T × Φ)∗, where (T × Φ)∗denotes some amount of transactions in
T × Φ. At the i-th turn, the schedule for any j∈[i+ 1, T ]is unknown to system actors.
Allocation rule. The allocation rule xdefines the mechanism’s allocation of transactions
to the upcoming block. It is possible that xis randomized; in that case, it maps to ∆((T ×
Φ)B). We denote the set of transactions allocated in the j-th turn by xj.
2.2 The Miner
We examine a far-sighted miner who plans the allocation of transactions to Tblocks.
Allocation strategy. The miner’s strategy is given by its allocation algorithm x.
Discount factor. Miners may prefer to receive revenue earlier rather than later, as de-
pendent on the economy’s interest rate. This is captured by the discount factor λ≤1.
Mining ratio. At each turn, the probability of choosing a miner to create a block is equal
to its mining ratio, denoted as α∈[0,1] and assumed to be constant, similarly to prior art
[22,24,66]. The chosen miner has the sole authority to select which transactions to allocate
to it, we thus define the helper function: α(j) = (1j= 0
α j ≥1.
Mempool. Valid transactions that were not yet allocated to a block or expired are stored
in a data structure called the memory pool (mempool). In Definition 2.1, we formalize
the mempool as a function which receives the current turn as input, and outputs the set
of transactions viable for inclusion. Our definition relies on a useful notion of “leftover”
transactions which are still unallocated and thus are carried over to the next round, with
the mempool decreasing their TTL correspondingly, and then pruning those which expired.
Definition 2.1 (Leftover transactions and Mempool function).The mempool function µ:
{0, . . . , T } → (T ×Φ)∗is defined recursively, starting intially from µ(0) def
=∅. Given schedule
6
ψ, some round jand the corresponding mempool µ(j), we define the set l(j+ 1) of leftover
transactions remaining after accounting for the allocation of the current round xjas:
l(j+ 1) def
= (µ(j)∪ψ(j)) \xj.
After decreasing the TTL of each leftover transaction in l(j+ 1), the mempool for the next
turn µ(j+ 1) is defined as the set of transactions which have not expired yet:
µ(j+ 1) def
={(t−1, f )|t > 1}(t,f)∈l(j+1).
Miner utility. Given a transaction schedule ψ, the utility function of using an allocation
algorithm xis denoted by u(x|ψ). We first formalize the utility for a single round in Defini-
tion 2.2, and then extend it to several rounds in Definition 2.3. We follow with Example 2.4,
which illustrates these definitions by giving a concrete instantiation of the utility function.
Definition 2.2 (Single round utility).Let µ(j)be the mempool at turn j, after accounting
for the allocations made until that point x1, . . . , xj−1, and the schedule thus far. Given a
user ithat is allocated in the j-th turn, denote its transaction by ϕi, and the fees of all other
transactions by ϕ−i. The expected utility of using xat the j-th turn is:
uj(x|ψ, x1, . . . , xj−1)def
= E[ X
ϕi∈
x(ψ(j)∪µ(j))
ϕx(j)|ψ, x1, . . . , xj−1],
where the expectation is taken over the randomness used for the allocation, if it is randomized.
Definition 2.3 (Total utility).For all j, denote the allocation made at round jby xj. Given
discount factor λand miner ratio function α(·), the expected utility until round Tis:
u(x|ψ)def
= E[
T
X
j=0
α(j)λjuj(x|ψ, x1, . . . , xj−1)],
where the expectation is taken over the randomness of x1, . . . , xj−1given the possibly ran-
domized algorithm xused at each step, which can depend on the miner elected at each block.
Definition 2.3 takes a nice form in the deterministic case, as shown by Example 2.4.
Example 2.4 (Revenue in the deterministic setting).Assume that all miners use the same
deterministic algorithm x, all transactions are of the form (t, ϕ), and the blocksize is B= 1.
Then, the total utility given mining ratio function α(·)and discount λis:
u(x|ψ) =
T
X
j=0
α(j)·λj·ϕx(ψ(j)∪µ(j)).
Remark 2.5. As our main results show, it is reasonable that miners would use the same
allocation algorithm. We further discuss the implications of homogeneity and heterogeneity
in miners’ choices of allocation algorithms in Section 7.
7
2.3 Game Model
Setting. To evaluate the performance of different allocation algorithms, we examine a
game between a miner and an adversary who creates a transaction schedule designed to
minimize the miner’s revenue. The main challenge of this game is that the miner has no
foresight of future transactions that will be sent by the adversary, so planning solely based
on the partial information accumulated so far (i.e., previous transactions) may not be the
best course of action. However, somewhat surprisingly, we later show that it is in fact so.
Remark 2.6. In-line with the literature, the term “adversary” is used to describe the entity
responsible for creating the transaction schedule. When considering a public cryptocurrency,
the users active in the system can be thought of as an adversarial omniscient “nature”. While
users may not necessarily actively try to minimize mining revenue, adopting this perspective
is useful when analyzing the worst-case revenue guarantees of allocation algorithms.
Competitive ratio. The quality of an online allocation algorithm xwhen faced with a
worst-case adversary ψis quantified by dividing the utility xobtains with the utility obtained
by the best possible offline algorithm x′. The resulting quantity is called x’s competitive ratio,
and is formalized using our notations in Definition 2.7. An upper-bound is then attained
by finding an allocation algorithm that guarantees good performance, and a lower-bound is
attained by showing that no allocation algorithm can guarantee better performance.
Definition 2.7 (Competitive ratio).Given an allocation algorithm x: (T ×Φ)∗→(T ×Φ)B,
its competitive ratio under block-size Bis defined as: Rx
def
= minψu(x|ψ)
maxx′u(x′|ψ).
Remark 2.8. For simplicity, Definition 2.7 uses maxx′u(x′|ψ)rather than supx′u(x′|ψ).
This is in-line with the literature, such as the classic work of Hajek [33]. Definition 2.7
moreover implies that the competitive ratio of any algorithm xis Rx≤1, with a ratio closer
to 1implying that the performance of xis closer to optimal. On the other hand, some adopt
an inverse definition where a “good” competitive ratio is lower, rather than higher.
3 Revisiting the Classic Greedy Allocation
The Greedy allocation algorithm (see Definition 3.1) is a classic approach to packet schedul-
ing which was explored by prior art for the undiscounted case [33,36]. Moreover, previous
work suggests that miners greedily allocate transactions to blocks [61,77], with empirical
studies showing that transactions paying higher fees generally have a lower mempool waiting
time, meaning that they are included relatively quickly in blocks [46,49,53,68]. Indeed, the
default transaction selection algorithms for Bitcoin Core (the reference implementation for
Bitcoin clients) and geth (Ethereum’s most popular execution client) prioritize transactions
based on their fees. It is thus of interest to evaluate the performance of this approach.
Definition 3.1 (The Greedy allocation algorithm).The Greedy allocation algorithm chooses
the highest paying transaction present in the input set S, disregarding TTL:
Greedy(S)def
= arg max
(t,ϕ)∈S
ϕ
If there are multiple transactions with the same fee, these with the lowest TTL are preferred.
8
Step
1 2 3 4
Transaction (TTL, fee)
ψ(1)
(1,2)
(2,4)
ψ(2) (2,6)
ψ(4) (1,8)
←Broadcast
→Expiration
OP T for λ= 1
OP T for λ=1
4
Greedy
Figure 5: An illustration of Example 3.2. At every step i, the adversary broadcasts the
transaction set ψ(i). Each transaction is denoted by a tuple of its TTL and fee, and is
depicted visually by a line stretching between the turn at which it was broadcast and the
one at which it expires becomes ineligible for inclusion. The algorithm Greedy allocates
the highest-fee transaction at each step, while OP T is the optimal allocation given some
discount rate λ. The choices made at each step by OP T for a discount rate of λ= 1,
OP T for λ=1
4and Greedy are denoted by a red star, blue circle, and a green rectangle,
correspondingly. In the undiscounted case, meaning λ= 1, if the miner ratio is α= 1 the
optimal utility is 20 while Greedy obtains a lower utility of 18. For λ=1
4, the allocation
made by Greedy coincides with the optimal one, and achieves a utility of 37
32 .
In Example 3.2, we show how Greedy’s performance may depend on the discount rate.
Example 3.2. We examine Greedy’s performance given the following adversary ψ.
ψ(i)def
=
{(1,2),(2,8)},i=1
{(2,4)},i=2
{(1,8)},i=4
∅,otherwise
The transaction schedule defined by ψis depicted in Fig. 5. At turn 1the adversary
broadcasts two transactions: (1,2) which expires at the end of the turn and has a fee of
2, and (2,4) which pays a fee equal to 4and expires at the end of the next turn. Because
Greedy prioritizes transactions with higher fees, it will allocate (2,4), while letting the other
transaction expire. In the next turn, the adversary broadcasts a single transaction with a
TTL of 2and a fee of 6, which is the only one available to Greedy at that turn, and thus
will be allocated. At step 3, the adversary does not emit any transactions, and on step 4, a
transaction (1,8) is broadcast and then allocated by Greedy.
Assume a mining rate of α= 1, and a discount rate of λ= 1. Given these parameters,
Greedy’s allocation obtains a discounted utility of 18 when facing ψ. On the other hand,
under the same setting, the optimal allocation, denoted by OP T , “saves” the transaction
(2,4) ∈ψ(1) to the second turn, and allocates (1,2) in the first. Similarly, it waits until the
9
third step to allocate (2,6) ∈ψ(2), and in the final step it allocates (1,8) ∈ψ(4). The total
discounted utility for OP T is 20.
Note that by definition, Greedy’s allocation does not depend on the miner’s discount and
mining rates. Thus, given α= 1 and λ= 0.25, the discounted utility of Greedy equals
37
32 = 4−1·4+4−2·6+4−4·8. On the other hand, O P T is heavily impacted by the choice
of parameters. In particular, for these mining and discount rates, the optimal allocation
coincides with that of Greedy, while the previous allocation made by OP T obtains a utility
of 7
8= 4−1·2 + 4−2·4 + 4−3·6 + 4−4·8. Thus, it is perhaps natural to expect that Greedy’s
competitiveness improves with lower discount factors.
In Claim 3.3, we derive the competitive ratio of Greedy as a function of λ.
Claim 3.3. If α= 0, the competitive ratio of the Greedy algorithm is RGreedy =1
1+λ.
The proof is given in Appendix A.
4 The General Deterministic Case
In this section, we focus on the general deterministic case for our discounted model with
miner ratio α= 0 and some discount rate λ. Missing proofs are given in Appendix A.
4.1 Deterministic Upper Bound
Previous competitive ratio bounds for the undiscounted case rely on constructions that do
not capture the discounted case, and cannot apply there. For example, the deterministic
undiscounted upper bound equals one over the golden ratio 1
ϕ≈0.618 [71], but as we see
in Claim 3.3, even the “naive” Greedy algorithm outperforms this bound for some discount
factors λ. In Theorem 4.1, we prove an upper bound on the performance of any allocation
algorithm in this broader setting.
Theorem 4.1 (Deterministic Upper Bound).Let ℓ=1
2(λ+pλ2+ 4). Then, any deter-
ministic allocation algorithm ALG has RALG ≤1
ℓ.
Proof. We prove the bound for λℓ < 1, which happens when λ < 1
√2≈0.707107. The more
complex proof for the general case appears in Appendix A.
Consider a series of adversaries {ψn}∞
n=1, defined inductively in Eq. (1).
∀n∈N:ψn(i)def
=
∅,i≤0or n<i
ψn−1(i),i<n
1, ℓn−1,(2, ℓn),i=n
ψ∞(i)def
=ψi(i)(1)
We first illustrate the construction. For n= 1, we get that ψ1(1) = {(1,1) ,(2, ℓ)}, and
∀i= 1 : ψ1(i) = ∅. Thus, the adversary sends two transactions in step 1, and does not
broadcast any other transaction. The first of these transactions, (1,1), pays a fee equal to 1
and expires at the end of the turn. The second transaction, (2, ℓ), expires at the end of the
next turn and pays a fee of ℓ.
10
The adversary ψ2offers two transactions in step 2:ψ2(2) = (1, ℓ),2, ℓ2. Similarly
to the previous case, the former transaction expires at the end of step 2, and the latter at
the end of step 3. The general case where n > 1is depicted in Fig. 6.
Consider any deterministic algorithm ALG, and let n+ 1 be the first index where it
chooses a transaction with TTL = 2 when facing the adversary ψ∞. We now split the proof
according to whether such an index exists or not.
Case I: no such index exists.
Due to our choice of ℓ=1
2(λ+pλ2+ 4), then ℓ≥1for any 0≤λ≤1. Thus, we compare
ALG’s performance with Greedy that chooses the highest-fee transaction at each step:
RALG = min
ψ
u(ALG|ψ)
maxx′u(x′|ψ)
≤u(ALG|ψ∞)
maxx′u(x′|ψ∞)
≤u(ALG|ψ∞)
u(Greedy|ψ∞)
=P∞
i=1 λiℓi−1
P∞
i=1 λiℓi
=1
ℓ.
Case II: the index exists.
Now, we consider the case where algorithm ALG eventually chooses a transaction with TTL
equal to 2, meaning that n+1 is well defined. Given our construction, this necessarily means
that there will be no transactions to carry over from turn n+ 1 to n+ 2.
Given the adversary ψn+1, depicted in Fig. 7, we compare the performance of ALG with
the allocation Greedy′that chooses greedily in all steps 1≤i≤n, then chooses at step
n+ 1 a transaction with TTL = 1, and finally picks the single remaining transaction at step
n+ 2. One can then verify that ALG achieves the (weakly) best ratio against Greedy′when
n= 0 (thus minimizing to zero the number of steps where Greedy′chooses a higher-fee
transaction greedily). By our construction, the latter transaction pays a fee of ℓn+1, thus:
RALG = min
ψ
u(ALG|ψ)
maxx′u(x′|ψ)
≤u(ALG|ψn)
u(Greedy′|ψn)
≤ℓ
u(Greedy′|ψ1)
=ℓ
1 + λℓ
=1
ℓ.(2)
11
Step
123... nn+ 1
Transaction (TTL, fee)
ψn(1)
(1, ℓ0)
(2, ℓ1)
ψn(2)
(1, ℓ1)
(2, ℓ2)
ψn(n)
(1, ℓn−1)
(2, ℓn)
.
.
.
←Broadcast
→Expiration
ALG
Greedy
Figure 6: A depiction of the first scenario presented in Theorem 4.1, where the algorithm
ALG always chooses transactions with a TTL of 1up until and including step n. In some
cases, ALG has multiple equivalent choices, which do not affect the analysis. For example,
in the n+1 step ALG can choose between two transactions that expire at the end of the turn
and have a fee of ℓ1: Either the one that carries over from step n, or the (1, ℓn)transaction
introduced in step n+ 1. Because Greedy picks the highest-fee transactions, at step nit
will choose the transaction (2, ℓn)∈ψn(n).
The last equation holds due to having ℓ=1
2(λ+pλ2+ 4), which implies 2ℓ−λ=pλ2+ 4,
and thus also that 4ℓ2−4ℓλ +λ2=λ2+ 4, allowing to conclude that ℓ2= 1 + λℓ.
4.2 The Immediacy-Biased Class Of Allocation Algorithms
We proceed by introducing the immediacy-biased class of allocation algorithms, and identify
a regime of discount rates λwhich we call the “semi-myopic” regime where it achieves
the optimal deterministic competitive ratio. Given a parameter ℓ∈ R, we denote the
corresponding instance of this class as ℓIB and define it in the following manner:
Definition 4.2 (The ℓ-immediacy-biased algorithm (ℓIB)).For a set S, let:
m>1= max
(t,f)∈Ss.t. t>1f,
m1= max
(t,f)∈Ss.t. t=1 f
If m>1
m1≥ℓ, choose the transaction matching m>1; otherwise, choose that matching m1.
Intuitively, the ℓI B algorithm is somewhat biased towards greediness, but the best trans-
action that immediately expires has a preference over the best transaction that expires in
future blocks, as long as it is not ℓtimes worse, or more. In particular, we are interested
in the case where ℓ=1
2(λ+pλ2+ 4). This choice is justified since we show we can upper
12
Step
1 2 3 ... nn+ 1 n+ 2
Transaction (TTL, fee)
ψn+1(1)
(1, ℓ0)
(2, ℓ1)
ψn+1(2)
(1, ℓ1)
(2, ℓ2)
ψn+1(n)
(1, ℓn−1)
(2, ℓn)
ψn+1(n+ 1)
(1, ℓn)
(2, ℓn+1)
.
.
.
←Broadcast
→Expiration
ALG
Greedy′
Figure 7: The setting described in the proof of the deterministic upper bound (see Theo-
rem 4.1), for the case where ALG picks a transaction with a TTL equal to 2.
bound any ℓIB allocation by both 1
ℓand ℓ
1+λℓ (Claim 4.6), so the only way to achieve the
optimal upper bound of Theorem 4.1 is by making this choice. Moreover, we are able to
precisely pinpoint the regime for which it is optimal, which is whenever λ≲0.77. This is
since we prove an upper bound of 1+λℓ
1+λ+λ2ℓ+λ3, and a lower bound of 1
1+λ3. As Fig. 1shows,
these bounds take precedence over the 1
ℓbound exactly at ≈0.77, where
1 + λℓ
1 + λ+λ2ℓ+λ3=1
1 + λ3=1
ℓ.
Before providing the lower and upper bound analysis, we comment on how our algorithm
stands in comparison with the MG algorithm of Li, Sethuraman, and Stein [43]. While the
ℓIB algorithm considers only the highest TTL = 1 transaction as a possible candidate
to be scheduled instead of the highest-fee transaction, MG considers any earliest-deadline
transaction. I.e., the algorithms differ in their behavior when no TTL = 1 transactions are
available. However, in terms of competitive analysis, the ℓI B algorithm dominates ℓMG.
That is because whenever ℓIB chooses a TTL = 1 transaction, ℓMG does the same. On
the other hand, in case that ℓIB chooses the highest-fee transaction, we can force ℓMG to
do the same by adding a (1, ϵ)with a sufficiently small ϵto the adversary’s schedule at that
step. Therefore, we can force ℓMG to make the same choices as the ℓIB algorithm, without
changing the optimal allocation performance.
We bound the allocation algorithm’s competitive ratio from below in Theorem 4.3.
13
Theorem 4.3. Let α= 0 and ℓ=1
2(λ+pλ2+ 4), then: RℓIB ≥min n1
ℓ,1
1+λ3o.
The result is based on the following technical result:
Claim 4.4. For any ℓ, let Ξ(ℓ) = max ℓ, 1+ℓλ
ℓ,1 + λ3, then RℓIB ≥1
Ξ(ℓ).
Setting ℓ=1+λℓ
ℓminimizes max{1+λℓ
ℓ, ℓ}. Solving the former, we get ℓ=1
2(λ+pλ2+ 4).
We now show an upper bound for the ℓIB algorithm.
Claim 4.5. With α= 0, let ℓ=1
2(λ+pλ2+ 4), then:
RℓIB ≤min (1
ℓ,1 + λℓ
1 + λ+λ2ℓ+λ3,min
n≥1Pn+1
i=0 λi
P2n
i=0 λi).
The result follows from the following technical result, when setting ℓ=1
2(λ+pλ2+ 4):
Claim 4.6. For any ℓ, let Ξ(ℓ) = max{ℓ, 1+λ+λ2ℓ+λ3
1+λℓ ,1+ℓλ
ℓ,maxn≥1P2n
i=0 λi
Pn+1
i=0 λi}, then:
RℓIB ≥1
Ξ(ℓ).
5 The Randomized Case
In this section, we consider randomized allocation algorithms. Thus, we should clarify how
the adversary may react, as the the previous setting only accounted for fixed deterministic
adversaries. We consider the stronger adaptive adversary, that may randomize its own
transaction schedule, and also has the information of past choices of the algorithm and
can use when choosing its future course of action. Such strong adversaries are naturally
applicable to the blockchain setting, where the contents of new blocks are public.
5.1 Randomized Upper Bound
To understand how randomization can help us, we prove an upper bound on the competitive
ratio of any (possibly randomized) allocation algorithm in Theorem 5.1.
Theorem 5.1. Given α= 0, for any (possibly randomized) allocation algorithm ALG:
RALG ≥1−λ
4
In our proof, we use a recursive construction of adversaries where the fees grow exponen-
tially. The choice of the exponent’s base, which we denote by x, is crucial for the analysis.
To make this choice, we denote the probability that at some step the algorithm chooses the
TTL = 1 transaction by p, and use the following equation, which turns out to work well:
p+ (1 −p)·x
1 + λ·x=p+ (1 −p)·x
x+p·λ·x,
when p=1
2. Here, the denominators represent two possible choices of the adaptive adversary.
14
5.2 The RDI SC Randomized Allocation Algorithm
We now devise a randomized allocation algorithm and prove that its performance guarantees
exceed those attained by the best possible deterministic algorithm. Our construction takes
some inspiration from the classic RMIX algorithm of Chin et al. [11] for the undiscounted
case, which, in turn, builds on the preceding work of Chrobak et al. [12]. To fit the more
general discounted setting, we enrich our algorithm with a parametrization which accounts
for the rate λ. As we show in the proof, this parametrization is delicate and cannot be
done naïvely: the sampling step that RDISC relies on should be carefully performed when
considering the economy’s discount factor.
Definition 5.2 (RDISCλ).Let ϕmax, ϕurg respectively be the highest-fee available transac-
tion, and the lowest-TTL transaction that offers the highest fee. RDISCλis the randomized
algorithm that samples x∼UNI([−λ, 0]) (the uniform distribution over the interval [−λ, 0]),
and transmits ϕurg if and only if ϕurg ≥ex·ϕmax, and otherwise transmits ϕmax.
Theorem 5.3. Given α= 0,RDISCλhas RRDISCλ≥1−e−λ
λ.
Notably, in the semi-myopic range that we identify in Section 4.2, our deterministic
algorithm achieves very similar performance to the above randomized allocation algorithm.
6 Additional Related Work
6.1 Transaction Fees
A line of work assumes users and miners are myopic and applies auction theory to the design
of blockchain transaction fee mechanisms (TFMs) [8,14,23,31,32,39,60,72,80]. Consid-
erations such as transactions with a finite TTL and non-myopic actors are beyond the scope
of this literature and are recognized as important gaps in our understanding of TFMs [39,
73], which later work began addressing. Nisan [51] emphasizes the fee dynamics given that
users are patient (have infinite deadlines) and price-takers (do not consider waiting for later
rounds). Penna and Schneider [56] study a similar setting where users are “quasi-patient”,
i.e., they have time-discounted preferences, as we consider as well. Kiayias et al. [38] sug-
gest allocating transactions using tiered mechanisms, where low urgency transactions may
face lower priority but also lower prices. Several works analyze and extend dynamic mecha-
nisms such as Ethereum’s EIP1559, and analyze their dynamic behavior, welfare guarantees,
pathological behavior and manipulability [3,25,41,42,52]. Pai and Resnick [54] suggest
using the incentive-compatible dynamic mechanism of Parkes and Singh [55].
6.2 Packet Scheduling
A rich literature studies a closely-related question to the one we formulate, that of packet
scheduling. Moreover, its focus is as ours on using the competitive ratio method to evaluate
possible algorithms. Hajek [33] shows that greedily choosing the highest weight packet (in
our terms: the highest-fee transaction) guarantees a competitive ratio of 2. We obtain a
more general result in Claim 3.3, and show that with a general discount factor λ, it achieves
15
a competitive ratio of 1
1+λ. Notice that with λ= 0, i.e., in the myopic case where only the
current step matters, choosing greedily becomes optimal, as expected. Moreover, [33] [33]
proves an optimal deterministic bound of 1
ϕ≈0.618. We identify that the key property of
the golden ratio that makes it “work” as the upper bound is that it satisfies: ϕ
1+ϕ=1
ϕ, and
find that we can develop a version of this equation parameterized by the discount factor λ:
r
1+λ·r=1
r, and solve it as r=1
2λ+pλ2+ 4. We show that this yields an optimal bound
in the discounted case for a large regime of parameters.
The packet scheduling literature continued by presenting optimal algorithms for both
specific sub-cases (e.g., when deadlines are “agreeable”) [43], and also for the general undis-
counted case [71]. Li, Sethuraman, and Stein [43] show that when the packets have agreeable
deadlines, i.e., when earlier arriving packets also have earlier deadlines, an algorithm they
call MG that chooses the best early-deadline packet if and only if it is at least 1
ϕas good
as the heaviest packet, leads to an optimal algorithm. As we show, our ℓIB algorithm (see
Definition 4.2) performs at least as well as MG in terms of competitive ratio in the general
case, and is itself bounded by 1
2. I.e., we can conclude that MG performs no better than
Greedy in the general case. Veselý et al. [71] use a memoryless algorithm as a stepping stone
to designing an optimal deterministic algorithm which is not memoryless. In both cases,
this type of memoryless algorithm does not achieve the optimal deterministic guarantee. It
is thus quite surprising that we are able to show a different result in the discounted case,
where the ℓIB algorithm achieves optimal performance for a large regime of discount factors
λ, which we call the semi-myopic regime of λ≲0.770018.
The literature also considered randomized algorithms and upper bounds. Chin et al. [11]
suggest a randomized algorithm that uses a randomized coefficient to determine which packet
to choose. Bienkowski, Chrobak, and Jeż [9] extend the analysis of RM I X from the oblivious
adversary model to the adaptive adversary one, and also provide an upper bound for any
randomized algorithm facing an adaptive adversary. See Veselý [69] for an overview of the
packet scheduling literature, including open problems in the field.
6.3 Other Literature
There are works that, while not completely related, do deserve mentioning. For example,
Fiat, Mansour, and Nadav [26] analyze the decision of whether to accept packets to a
first-in-first-out (FIFO) queue in a latency-sensitive model. Fiat et al. [27] analyze single-
minded users who assign both a fee and some urgency to their requests, albeit from a
strategic Bayesian perspective. Furthermore, considering expiration date for transactions
means that our setting is related to other time-constrained resource allocation problems,
such as deadline-aware job scheduling [63] and ride-sharing [19].
7 Discussion
Memorylessness. We show that a novel memoryless algorithm achieves the deterministic
upper bound in the semi-myopic case. We provide a tight characterization of this optimality,
and so that algorithm cannot achieve optimality with larger values of λ. When considering
deterministic algorithms which are not memoryless, Veselý et al. [71] present an optimal
16
construction for the undiscounted case. An interesting direction for future work is to see if
this elegant algorithm maintains its optimality in the discounted case (i.e., when λ < 1).
Present bias. It is interesting that the miner ratio (which embodies a miner’s present
bias) does not appear explicitly in the results. Technically, this is because for all the upper
bounds, we can ignore the first transaction in building our adversarial sequences. For the
Greedy and ℓIB algorithms, the case analyses consist of either direct comparisons within
the same step, or of chains where the algorithm has the earliest transaction at least as high
as OPT. In the analysis of RDISC, it is because the potential function has value 0at the
first step. On a deeper level, this is because our algorithms are somewhat biased towards
allocating heavier transactions earlier.
Heterogeneous miners. In the paper’s analysis, miners operate under the assumption
that blocks built by others follow the same allocation. This is bolstered by our finding that
the optimal semi-myopic algorithm does not depend on the mining ratio, if it is greater
than 0 (i.e, α > 0). Indeed, previous work show that block building in major blockchains is
dominated by a small number of large actors [1,5,79], as supported by the empirical data
we present in Figs. 2to 4and Tables 3to 5. However, if some miners are “atomic” and
have a ratio α= 0, then it is optimal for them to act greedily. Understanding the impact of
heterogeneity in the choice of allocation algorithms is an open question.
General time-dependent models. While multiplicative discounting is a natural model
and common in the economic literature, other models can be of interest. For example, one
may consider personalized discount rates, or transactions that specify a per-block fee, which
can even be monotonically increasing. The latter may be useful to prioritize transactions
that have been pending for a while, a-la Ethereum’s proposed fee “escalator” [61].
Semi-myopic discounts. The semi-myopic regime is relevant to notable settings such as
long-term project management, where one has to decide which projects to commit resources
to on a time scale of several years. Moreover, there are alternative interpretations to the
discount factor that show the usefulness of the semi-myopic range: One example is where
clients, on top of having a strict deadline after which they leave the system, may also
become impatient and leave following a geometric (memoryless) process. Another example
is the one we discussed regarding heterogeneous miners: λcan be interpreted as a rule-of-
thumb discount that stems from the probability of having miners with different allocation
rules decide the next block. Intuitively, our analysis shows that a particular benefit of
semi-myopic discount rates is that they lessen the impact of longer pathological chains of
adversarial sequences. We thus believe that extending our framework and using discounting
could yield interesting results when applied to other online problems.
References
[1] Nick Arnosti and S. Matthew Weinberg. “Bitcoin: A Natural Oligopoly”. In: Manage-
ment Science 68.7 (2022), pp. 4755–4771. doi:10.1287/mnsc.2021.4095.
17
[2] Itai Ashlagi et al. “ Edge Weighted Online Windowed Matching”. In: Proceedings of the
2019 ACM Conference on Economics and Computation. EC ’19. NY, NY, USA: ACM,
June 2019, pp. 729–742. isbn: 9781450367929. doi:10.1145/3328526.3329573.
[3] Sarah Azouvi et al. “ Base Fee Manipulation In Ethereum’s EIP-1559 Transaction Fee
Mechanism”. en. In: 37th International Symposium on Distributed Computing (DISC).
Ed. by Rotem Oshman. Vol. 281. Leibniz International Proceedings in Informatics
(LIPIcs). Germany: Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Apr. 2023,
6:1–6:22. isbn: 978-3-95977-301-0. doi:10.4230/LIPICS.DISC.2023.11.
[4] Maryam Bahrani and Naveen Durvasula. Resonance: Transaction Fees for Heteroge-
neous Computation. Nov. 2024. doi:10.48550/arXiv.2411.11789.
[5] Maryam Bahrani, Pranav Garimidi, and Tim Roughgarden. Centralization in Block
Building and Proposer-Builder Separation. 2024. doi:10.48550/arXiv.2401.12120.
[6] Maryam Bahrani, Pranav Garimidi, and Tim Roughgarden. “Transaction Fee Mech-
anism Design in a Post-MEV World”. In: 6th Conference on Advances in Financial
Technologies (AFT 2024). Ed. by Rainer Böhme and Lucianna Kiffer. Vol. 316. Leib-
niz International Proceedings in Informatics (LIPIcs). Dagstuhl, Germany: Schloss
Dagstuhl – Leibniz-Zentrum für Informatik, 2024, 29:1–29:24. isbn: 978-3-95977-345-
4. doi:10.4230/LIPIcs.AFT.2024.29.
[7] Maryam Bahrani, Pranav Garimidi, and Tim Roughgarden. “When Bidders Are DAOs”.
en. In: 5th Conference on Advances in Financial Technologies (AFT 2023). Ed. by
Joseph Bonneau and S. Matthew Weinberg. Vol. 282. Leibniz International Proceed-
ings in Informatics (LIPIcs). Germany: Schloss Dagstuhl – Leibniz-Zentrum für Infor-
matik, 2023, 21:1–21:21. isbn: 9783959773034. doi:10.4230/LIPIcs.AFT.2023.21.
[8] Soumya Basu et al. “StableFees: A Predictable Fee Market for Cryptocurrencies”. In:
Management Science 69.11 (Nov. 2023), pp. 6508–6524. issn: 1526-5501. doi:10 .
1287/mnsc.2023.4735.
[9] Marcin Bienkowski, Marek Chrobak, and Łukasz Jeż. “Randomized competitive algo-
rithms for online buffer management in the adaptive adversary model”. In: Theoretical
Computer Science 412.39 (2011), pp. 5121–5131. issn: 0304-3975. doi:10. 1016/j .
tcs.2011.05.015.
[10] Allan Borodin and Ran El-Yaniv. Online computation and competitive analysis. Cam-
bridge, United Kingdom: Cambridge University Press, 2005.
[11] Francis Y.L. Chin et al. “Online competitive algorithms for maximizing weighted
throughput of unit jobs”. In: Journal of Discrete Algorithms 4.2 (2006), pp. 255–276.
issn: 1570-8667. doi:10.1016/j.jda.2005.03.005.
[12] Marek Chrobak et al. “Preemptive scheduling in overloaded systems”. In: Journal of
Computer and System Sciences 67.1 (Aug. 2003), pp. 183–197. issn: 0022-0000. doi:
10.1016/S0022-0000(03)00070-9.
[13] Hao Chung, Tim Roughgarden, and Elaine Shi. “Collusion-Resilience in Transaction
Fee Mechanism Design”. In: Proceedings of the 25th ACM Conference on Economics
and Computation. EC ’24. New Haven, CT, USA: Association for Computing Machin-
ery, 2024, pp. 1045–1073. doi:10.1145/3670865.3673550.
18
[14] Hao Chung and Elaine Shi. “Foundations of Transaction Fee Mechanism Design”.
In: Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms
(SODA). Philadelphia, PA: Society for Industrial and Applied Mathematics, 2023,
pp. 3856–3899. doi:10.1137/1.9781611977554.ch150.
[15] Ethereum Alarm Clock. Ethereum Alarm Clock. 2018. url:https:// github.com/
ethereum-alarm-clock/ethereum-alarm-clock.
[16] CoinMarketCap. Cryptocurrency Prices. 2025. url:https://web.archive.org/web/
20250123063252/https://coinmarketcap.com/.
[17] Philip Daian et al. “ Flash Boys 2.0: Frontrunning in Decentralized Exchanges, Miner
Extractable Value, and Consensus Instability”. In: 2020 IEEE Symposium on Security
and Privacy, SP 2020, San Francisco, CA, USA, May 18-21, 2020. San Francisco, CA,
USA: IEEE, 2020, pp. 910–927. doi:10.1109/SP40000.2020.00040.
[18] Evangelos Deirmentzoglou, Georgios Papakyriakopoulos, and Constantinos Patsakis.
“A survey on long-range attacks for proof of stake protocols”. In: IEEE Access 7 (2019),
pp. 28712–28725. doi:10.1109/access.2019.2901858.
[19] John P Dickerson et al. “Allocation problems in ride-sharing platforms: Online match-
ing with offline reusable resources”. In: ACM Transactions on Economics and Compu-
tation (TEAC) 9.3 (2021), pp. 1–17. doi:10.1145/3456756.
[20] Cardano Docs. Time handling on Cardano. 2024. url:https://github.com/input-
output - hk / cardano - documentation / blob / 62e7f5 / docs / about - cardano / 04 -
explore-more/09-time.mdx.
[21] Etherscan. Ethereum Network Pending Transactions Chart. 2022. url:https://web.
archive.org/web/20221013164749/https://etherscan.io/chart/pendingtx.
[22] Ittay Eyal and Emin Gün Sirer. “Majority is not enough: Bitcoin mining is vulnerable”.
In: International conference on financial cryptography and data security. Vol. 61. As-
sociation for Computing Machinery, June 2014, pp. 436–454. doi:10.1145/3212998.
[23] Matheus V. X. Ferreira, Yotam Gafni, and Max Resnick. Incentive-Compatible Collusion-
Resistance via Posted Prices. Dec. 2024. doi:10.48550/arXiv.2412.20853.
[24] Matheus V. X. Ferreira and S. Matthew Weinberg. “Proof-of-Stake Mining Games with
Perfect Randomness”. In: Proceedings of the 22nd ACM Conference on Economics and
Computation. EC ’21. Budapest, Hungary: Association for Computing Machinery,
2021, pp. 433–453. isbn: 9781450385541. doi:10.1145/3465456.3467636.
[25] Matheus V. X. Ferreira et al. “Dynamic Posted-Price Mechanisms for the Blockchain
Transaction-Fee Market”. In: Proceedings of the 3rd ACM Conference on Advances
in Financial Technologies. AFT ’21. Arlington, Virginia: Association for Computing
Machinery, 2021, pp. 86–99. isbn: 9781450390828. doi:10.1145/3479722.3480991.
[26] Amos Fiat, Yishay Mansour, and Uri Nadav. “Competitive queue management for
latency sensitive packets”. In: Proceedings of the Nineteenth Annual ACM-SIAM Sym-
posium on Discrete Algorithms. SODA ’08. San Francisco, California: Society for Indus-
trial and Applied Mathematics, 2008, pp. 228–237. doi:10.5555/1347082.1347108.
19
[27] Amos Fiat et al. “The FedEx Problem”. In: Proceedings of the 2016 ACM Conference
on Economics and Computation. EC ’16. Maastricht, The Netherlands: ACM, 2016,
pp. 21–22. isbn: 9781450339360. doi:10.1145/2940716.2940752.
[28] Irving Fisher. The purchasing power of money: its’ determination and relation to credit
interest and crises. The Macmillan Company, 1911. url:https://fraser.stlouisf
ed.org/title/purchasing-power-money-3610.
[29] Irving Fisher. The Theory of Interest. The Macmillan Company, 1930. url:https:
//oll.libertyfund.org/titles/fisher-the-theory-of-interest.
[30] Flashbots. Private Transactions. 2023. url:https : / / web . archive . org / web /
20230521052523/https://docs.flashbots.net/flashbots-auction/searchers/
advanced/private-transaction.
[31] Yotam Gafni and Aviv Yaish. “Barriers to Collusion-resistant Transaction Fee Mecha-
nisms”. In: Proceedings of the 25th ACM Conference on Economics and Computation.
EC ’24. New Haven, CT, USA: Association for Computing Machinery, 2024, pp. 1074–
1096. doi:10.1145/3670865.3673469.
[32] Yotam Gafni and Aviv Yaish. “Discrete and Bayesian Transaction Fee Mechanisms”.
In: Mathematical Research for Blockchain Economy. Ed. by Stefanos Leonardos et al.
MARBLE ’24. Malaga, Spain: Springer Nature Switzerland, 2024, pp. 145–171. isbn:
978-3-031-68974-1. doi:10.1007/978-3-031-68974-1_8.
[33] Bruce Hajek. “On the competitiveness of on-line scheduling of unit-length packets with
hard deadlines in slotted time”. In: Proceedings of the 2001 Conference on Information
Sciences and Systems. 2001. url:https : / / hajek . ece . illinois . edu / Papers /
Hajek01_OL.pdf.
[34] Joe Halpern, Rafael Pass, and Aditya Saraf. Fair Interest Rates Are Impossible for
Lending Pools: Results from Options Pricing. 2024. doi:10 . 48550 / arXiv . 2410 .
11053.
[35] Gur Huberman, Jacob D Leshno, and Ciamac Moallemi. “Monopoly without a Mo-
nopolist: An Economic Analysis of the Bitcoin Payment System”. In: The Review of
Economic Studies 88.6 (Mar. 2021), pp. 3011–3040. issn: 0034-6527. doi:10.1093/
restud/rdab014.
[36] Alexander Kesselman et al. “ Buffer overflow management in QoS switches”. In: Pro-
ceedings of the thirty-third annual ACM symposium on Theory of computing. STOC
’01. New York, NY, USA: Association for Computing Machinery, July 2001, pp. 520–
529. isbn: 9781581133493. doi:10.1145/380752.380847.
[37] Aggelos Kiayias et al. “Ouroboros: A provably secure proof-of-stake blockchain pro-
tocol”. In: 2019 IEEE Symposium on Security and Privacy, SP 2019, San Francisco,
CA, USA, May 19-23, 2019. San Francisco, CA, USA: IEEE, 2019, pp. 157–174. doi:
10.1109/SP.2019.00063.
[38] Aggelos Kiayias et al. “ Tiered Mechanisms for Blockchain Transaction Fees”. In: Math-
ematical Research for Blockchain Economy. Ed. by Stefanos Leonardos et al. Cham:
Springer Nature Switzerland, 2024, pp. 1–26. isbn: 978-3-031-68974-1. doi:10.1007/
978-3-031-68974-1_1.
20
[39] Ron Lavi, Or Sattath, and Aviv Zohar. “Redesigning Bitcoin’s Fee Market”. In: ACM
Trans. Econ. Comput. 10.1 (May 2022). issn: 2167-8375. doi:10.1145/3530799.
[40] XRP Ledger. Reliable Transaction Submission. 2025. url:https : //web.archive .
org / web / 20250123074655 / https : / / xrpl . org / docs / concepts / transactions /
reliable-transaction-submission#lastledgersequence.
[41] Stefanos Leonardos et al. “ Dynamical Analysis of the EIP-1559 Ethereum Fee Market”.
In: Proceedings of the 3rd ACM Conference on Advances in Financial Technologies.
AFT ’21. Arlington, Virginia: Association for Computing Machinery, 2021, pp. 114–
126. isbn: 9781450390828. doi:10.1145/3479722.3480993.
[42] Stefanos Leonardos et al. “ Optimality Despite Chaos in Fee Markets”. In: Lecture
Notes in Computer Science. Cham: Springer Nature Switzerland, Dec. 2023, pp. 346–
362. isbn: 9783031477515. doi:10.1007/978-3-031-47751-5_20.
[43] Fei Li, Jay Sethuraman, and Clifford Stein. “An optimal online algorithm for packet
scheduling with agreeable deadlines”. In: Proceedings of the sixteenth annual ACM-
SIAM symposium on Discrete algorithms. SODA ’05. USA: Society for Industrial and
Applied Mathematics, Jan. 2005, pp. 801–802. doi:10.5555/1070432.1070544.
[44] Sheng-Nan Li, Zhao Yang, and Claudio J. Tessone. “ Mining blocks in a row: A sta-
tistical study of fairness in Bitcoin mining”. In: IEEE International Conference on
Blockchain and Cryptocurrency, ICBC 2020, Toronto, ON, Canada, May 2-6, 2020.
Toronto, ON, Canada: IEEE, 2020, pp. 1–4. doi:10.1109/ICBC48266.2020.9169436.
[45] Ya-Chun Liang, Clifford Stein, and Hao-Ting Wei. Learning-Augmented Online Packet
Scheduling with Deadlines. 2024. doi:10.48550/arXiv.2305.07164.
[46] Yulin Liu et al. “Empirical Analysis of EIP-1559: Transaction Fees, Waiting Times, and
Consensus Security”. In: Proceedings of the 2022 ACM SIGSAC Conference on Com-
puter and Communications Security. CCS ’22. LA, CA, USA: ACM, 2022, pp. 2099–
2113. isbn: 9781450394505. doi:10.1145/3548606.3559341.
[47] Sishan Long, Soumya Basu, and Emin Gün Sirer. Measuring Miner Decentralization
in Proof-of-Work Blockchains. 2022. doi:10.48550/arXiv.2203.16058.
[48] mempool.space. Mempool by vBytes. A graphical depiction of Bitcoin’s mempool for
the period between Oct ’19 and Oct ’22. 2022. url:https://web.archive.org/web/
20220823122255/https://mempool.space/graphs/mempool%5C#3y.
[49] Johnnatan Messias et al. On Blockchain Commit Times: An analysis of how miners
choose Bitcoin transactions. Online, 2020. url:https : / / people . mpi - sws . org /
~johnme/pdf/messias-sdbd-20.pdf.
[50] Jason Milionis et al. “ A Framework for Single-Item NFT Auction Mechanism Design”.
In: Proceedings of the CCS Workshop on Decentralized Finance and Security. NY, NY,
USA: ACM, Nov. 2022, pp. 31–38. doi:10.1145/3560832.3563436.
[51] Noam Nisan. Serial Monopoly on Blockchains. 2023. doi:10. 48550 /arXiv. 2311 .
12731.
[52] Noam Nisan and Moshe Babaioff. On the Optimality of EIP-1559 for Patient Bidders.
2024. url:https://www.cs.huji.ac.il/~noam/publications/patient1559.pdf.
21
[53] Michael Pacheco et al. “Is My Transaction Done yet? An Empirical Study of Transac-
tion Processing Times in the Ethereum Blockchain Platform”. In: ACM Trans. Softw.
Eng. Methodol. To appear. (July 2022). issn: 1049-331X. doi:10.1145/3549542.
[54] Mallesh Pai and Max Resnick. Dynamic Transaction Fee Mechanism Design. 2024.
url:https://www.mechanism.org/spec/04.
[55] David C Parkes and Satinder Singh. “An MDP-Based Approach to Online Mechanism
Design”. In: Advances in Neural Information Processing Systems. Ed. by S. Thrun, L.
Saul, and B. Schölkopf. Vol. 16. MIT Press, 2003. doi:10.5555/2981345.2981444.
[56] Paolo Penna and Manvir Schneider. Serial Monopoly on Blockchains with Quasi-patient
Users. May 2024. doi:10.48550/arXiv.2405.17334.
[57] Rated. Builders. Feb. 2025. url:https://web.archive.org/web/20250215225020/
https://explorer.rated.network/builders?network=mainnet&timeWindow=30d&
page=1.
[58] Rated. Ethereum Staking Pool Ratings. Feb. 2025. url:https://web.archive.org/
web / 20250215223642 / https : / / explorer . rated . network / ?network = mainnet &
view=pool&timeWindow=all&page=1&pageSize=15&poolType=all.
[59] Michel Rauchs and Garrick Hileman. Global Cryptocurrency Benchmarking Study.
Cambridge, United Kingdom: Cambridge Centre for Alternative Finance, Cambridge
Judge Business School, University of Cambridge, 2017. url:https:// EconPapers.
repec.org/RePEc:jbs:altfin:201704-gcbs.
[60] Tim Roughgarden. “Transaction Fee Mechanism Design”. In: J. ACM 71.4 (Aug.
2024). issn: 0004-5411. doi:10.1145/3674143.
[61] Tim Roughgarden. Transaction Fee Mechanism Design for the Ethereum Blockchain:
An Economic Analysis of EIP-1559. 2020. doi:10.48550/arxiv.2012.00854.
[62] Ayelet Sapirshtein, Yonatan Sompolinsky, and Aviv Zohar. “Optimal Selfish Mining
Strategies in Bitcoin”. In: Financial Cryptography and Data Security. Ed. by Jens
Grossklags and Bart Preneel. Berlin, Heidelberg: Springer, 2017, pp. 515–532. isbn:
978-3-662-54970-4. doi:10.1007/978-3-662-54970-4_30.
[63] Sukhpal Singh and Inderveer Chana. “A survey on resource scheduling in cloud com-
puting: Issues and challenges”. In: Journal of grid computing 14.2 (2016), pp. 217–264.
doi:10.1007/s10723-015-9359-2.
[64] Solana. Transaction Confirmation & Expiration. 2025. url:https://web.archive.
org/web/20250121092704/https://solana.com/docs/advanced/confirmation.
[65] TRON. FAQ. 2025. url:https://web.archive.org/web/20250121190035/https:
//developers.tron.network/docs/faq.
[66] Itay Tsabary and Ittay Eyal. “The Gap Game”. In: Proceedings of the 2018 ACM
SIGSAC Conference on Computer and Communications Security. CCS ’18. Toronto,
Canada: Association for Computing Machinery, 2018, pp. 713–728. isbn: 9781450356930.
doi:10.1145/3243734.3243737.
22
[67] Christos Tsanikidis and Javad Ghaderi. “Near-Optimal Packet Scheduling in Multi-
hop Networks with End-to-End Deadline Constraints”. In: Proc. ACM Meas. Anal.
Comput. Syst. 7.3 (Dec. 2023), 50:1–50:32. doi:10.1145/3626781.
[68] Kemal Turksonmez et al. “Two Ways Gas Price Oracles Miss The Mark”. In: 2021 IEEE
International Conference on Omni-Layer Intelligent Systems (COINS). Barcelona,
Spain: IEEE, Aug. 2021, pp. 1–7. doi:10.1109/COINS51742.2021.9524148.
[69] Pavel Veselý. “ Packet Scheduling: Plans, Monotonicity, and the Golden Ratio”. In:
SIGACT News 52.2 (June 2021), pp. 72–84. doi:10.1145/3471469.3471481.
[70] Pavel Vesel`y. “Online Algorithms for Packet Scheduling”. PhD thesis. Univerzita Karlova,
Matematicko-fyzikální fakulta, 2018. doi:20.500.11956/104429.
[71] Pavel Veselý et al. “ A ϕ-Competitive Algorithm for Scheduling Packets with Dead-
lines”. In: Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete
Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019. Ed. by
Timothy M. Chan. SIAM, 2019, pp. 123–142. doi:10.1137/1.9781611975482.9.
[72] Wenhao Wang et al. “ P r ooφ: A ZKP Market Mechanism”. In: Financial Cryptogra-
phy and Data Security. Ed. by Christina Garman and Pedro Moreno-Sanchez. Cham:
Springer Nature Switzerland, 2025. doi:10.48550/arXiv.2404.06495.
[73] Aviv Yaish. “Incentives in the Ether: Practical Cryptocurrency Economics & Secu-
rity”. In: Companion Proceedings of the ACM on Web Conference 2024. WWW ’24.
Singapore, Singapore: Association for Computing Machinery, 2024, pp. 1230–1233.
doi:10.1145/3589335.3651268.
[74] Aviv Yaish. “Intelligent Economic Agents, Cryptocurrencies & Distributed Ledgers”.
eng. PhD thesis. The Hebrew University of Jerusalem, 2024. url:https://huji.pri
mo.exlibrisgroup.com/permalink/972HUJI_INST/9os3m6/alma9921481359403701.
[75] Aviv Yaish, Saar Tochner, and Aviv Zohar. “Blockchain Stretching & Squeezing: Ma-
nipulating Time for Your Best Interest”. In: Proceedings of the 23rd ACM Conference
on Economics and Computation. EC ’22. Boulder, CO, USA: Association for Comput-
ing Machinery, 2022, pp. 65–88. doi:10.1145/3490486.3538250.
[76] Aviv Yaish and Aviv Zohar. “Correct Cryptocurrency ASIC Pricing: Are Miners Over-
paying?” In: 5th Conference on Advances in Financial Technologies (AFT 2023). Ed.
by Joseph Bonneau and S. Matthew Weinberg. Vol. 282. Leibniz International Pro-
ceedings in Informatics (LIPIcs). Germany: Schloss Dagstuhl – Leibniz-Zentrum für In-
formatik, 2023, 2:1–2:25. isbn: 978-3-95977-303-4. doi:10.4230/LIPIcs.AFT.2023.2.
[77] Aviv Yaish et al. “Speculative Denial-of-Service Attacks in Ethereum”. In: 33rd USENIX
Security Symposium (USENIX Security 24). Philadelphia, PA, Aug. 2024. url:https:
//www.usenix.org/conference/usenixsecurity24/presentation/yaish.
[78] Aviv Yaish et al. Suboptimality in DeFi. 2023. url:https://ia.cr/2023/892.
[79] Sen Yang, Kartik Nayak, and Fan Zhang. Decentralization of Ethereum’s Builder Mar-
ket. 2025. doi:10.48550/arXiv.2405.01329.
[80] Andrew Chi-Chih Yao. An Incentive Analysis of some Bitcoin Fee Designs. 2018. doi:
10.48550/arXiv.1811.02351.
23
A Proofs
Claim 3.3. If α= 0, the competitive ratio of the Greedy algorithm is RGreedy =1
1+λ.
Proof. We prove this result by separately showing the algorithm’s lower and upper bounds.
Part I: RGreedy ≤1
1+λ.
Consider an adversary ψwith ψ(1) = {(1,1),(2,1 + ϵ)}and ψ(i) = ∅for i= 0 and any
i≥2. Note that maxcu(x|ψ)≥αλ(1 + λ+λϵ). On the other hand, by substituting these
into Definition 2.3 one can obtain the following utility: u(Greedy|ψ) = αλ(1 + ϵ).
Part II: RGreedy ≥1
1+λ.
To prove this bound, we fix an adversary ψand compare Greedy with some allocation
algorithm x′. If Greedy under-performs x′at index i0, then it must be that the transaction
chosen by x′is not available to Greedy at this index. As this transaction is available to x′,
it means that it still did not expire and thus must have been chosen by Greedy at some
previous index i1. If at index i1Greedy under-performs x′, again it means that x′chooses
a transaction that is not available to Greedy and so must have been chosen by Greedy at
a previous index i2, and so on. Since i0is some finite index, there must be some number
kso that at ik,x′chooses a transaction that is available to Greedy, and Greedy weakly
outperforms it. Denote this “chain” of indices C={ik, . . . , i0}(notice that by our choice of
sub-indexing, ij+1 < ijfor any 0≤j≤k−1).
First, note that since for 0≤j≤k−1the allocation of Greedy at index ij+1 is the
same as the allocation of x′over the index ij, we have:
X
0≤j≤k−1
α(ij)λijϕ(x′(ψ(ij)∪µx′(ij))) = X
0≤j≤k−1
α(ij)λijϕ(Greedy(ψ(ij+1 )∪µGreedy (ij+1)))
=X
1≤j≤k
α(ij−1)λij−1ϕ(Greedy(ψ(ij)∪µGreedy(ij)))
≤λX
1≤j≤k
α(ij)λijϕ(Greedy(ψ(ij)∪µGreedy(ij)))
(3)
Notice our use of the fact that ij−1must be at least one round later than ij, and so
must be discounted by at least λrelative to it, as well as the fact that α(i)is monotone
decreasing with i(and thus is also monotone increasing with j).
Since Greedy weakly outperforms c′at ik, we have:
ϕ(x′(ψ(ik)∪µx′(ik))) ≤ϕ(Greedy(ψ(ik)∪µGreedy(ik))) (4)
Let C1, . . . , Cνbe all such chains of indices. Denote the length of some chain Cby k(C),
and the chain’s j-th index by iC
j. Let Obe all the indices that are not included in any chain.
Then, for any i∈O, a similar equation to Eq. (4) holds. Overall:
24
u(x′|ψ) = ∞
X
i=0
α(i)λiϕx′(ψ(i)∪µx′(i))
=
ν
X
s=1
k(Cs)−1
X
j=0
α(iCs
j)λiCs
jϕ(x′(ψ(iCs
j)∪µx′(iCs
j)))
+
ν
X
s=1
α(iCs
k(Cs))λiCs
k(Cs)ϕ(x′(ψ(iCs
k(Cs))∪µx′(iCs
k(Cs))))
+X
i∈O
α(i)λiϕ(x′(ψ(i)∪µx′(i)))
≤
ν
X
s=1
λ
k(Cs)
X
j=1
α(iCs
j)λiCs
jϕ(Greedy(ψ(iCs
j)∪µGreedy (iCs
j)))
+
ν
X
s=1
α(iCs
k(Cs))λiCs
k(Cs)ϕ(Greedy(ψ(iCs
k(Cs))∪µGreedy (iCs
k(Cs))))
+X
i∈O
α(iCs
j)λiCs
jϕ(Greedy(ψ(iCs
j)∪µGreedy (iCs
j)))
≤(1 + λ)
ν
X
s=1
k(Cs)
X
j=1
α(iCs
j)λiCs
jϕ(Greedy(ψ(iCs
j)∪µGreedy (iCs
j)))
+X
i∈O
α(i)λiϕ(Greedy(ψ(i)∪µGreedy(i)))
≤(1 + λ)u(Greedy|ψ)
Theorem 4.1 (Deterministic Upper Bound).Let ℓ=1
2(λ+pλ2+ 4). Then, any deter-
ministic allocation algorithm ALG has RALG ≤1
ℓ.
Proof. We first give an overview of the proof. The proof for the case λ < 1
√2gives us the
intuition that we should prove that when n→ ∞,x1
1+l∗x1→1
x1. However, when λℓ > 1, the
final terms are non-negligible, and in fact can be very large. We thus need to adjust the series
of fees x1, . . . , xnchosen by the adversary ψn, so that each choice of the algorithm results
in an equal competitive ratio. Our main insight is that this is enough to prove x1
1+l∗x1≥1
x1
for any n. We do so by showing that the ratios ri=xi
xi−1are monotone increasing in i.
25
Consider the set of adversaries Φn={ψi}n
i=1 ∪ {ψ′
n}, which we define inductively:
ψ1(0) = ∅,
ψ1(1) = {(1,1),(2, x1)},
∀j > 1, ψ1(j) = ∅
∀n≥i > 1,∀j < i, ψi(j) = ψi−1(j),
∀i > 1, ψi(i) = {(1, xi−1),(2, xi),
∀j > i, ψi(j) = ∅
∀j≤n, ψ′
n(j) = ψn(j),
ψn(n+ 1) = {(1, xn)},
∀j > n + 1, ψn(j) = ∅
Let ALG be any deterministic allocation algorithm. Let kbe the first index so that
ALG chooses a TTL = 2 transaction when facing ψ′
n, or undefined if there is no such index.
Then, if kis defined, when facing ψk,ALG achieves competitive ratio of at most:
Pk−1
i=1 λixi−1+λkxk
Pk−1
i=1 λixi+λkxk−1+λk+1xk
.
Otherwise, when facing ψ′
n,ALG achieves a competitive ratio of at most:
Pn
i=1 λixi−1+λn+1xn
Pn
i=1 λixi+λn+1xn
.
We now find such x1, . . . , xnso that the above n+ 1 expressions are all equal. Then,
no matter the choice of ALG, the competitive ratio will be upper-bounded by this value V.
We show that when nis large enough, this value tends to 1
λ
2+√4+λ2
2
.
The solution always satisfies x1
1+λx1≥1
x1.
There is always a unique solution x1≥0, . . . , xn≥0to this system of equations. Fix some
x1, then all other variables are determined by developing the equations and attaining the
recursive relation:
xi+1 =(1 + V)(xi−xi−1)
λ−V λ2(5)
where V=x1
1+λx1, x0= 1. We have another equation, which we also attain by subtracting:
xn=(1 + V)xn−1
(1 + V−λ).(6)
The denominators of the above equations are always positive. We prove that the numerator
is always positive (and thus all xi+1 ≥0) by inductively proving that xi≥xi−1. In fact, we
prove a much stronger property: If we let ri=xi
xi−1(and let r1=x1, r0= 1), we show that
riis monotonically increasing. We rewrite Eq. (5):
ri+1 =(1 + V)(1 −1
ri)
λ−V λ2.(7)
26
If for some i,ri> ri−1, then 1−1
ri>1−1
ri−1, and so at the next step the numerator will be
smaller and we will have ri+1 > ri, and so on. On the other hand, if for some i,ri≤ri−1,
then riis weakly monotone decreasing. For rn, we recast Eq. (6) as:
rn=1 + V
1 + V−λ.(8)
Assume towards contradiction that riis not monotonically increasing, then it must be that
it is weakly monotonically decreasing and:
1 + λx1+x1
1 + λx1−λ−λ2x1
=1 + V
1 + V−λ=rn≤r1=x1.
This implies a lower bound of x1≥1
1−λ(1 + 1
√λ). We can also directly develop the formula
for x2in terms of x1and λ, which results in: x2=(1+λ)(x2
1−1)
λ.Since it must be that ri
is weakly monotonically decreasing, then r2≤r1, i.e., x2≤x2
1. But, this is impossible
given the formula for x2and the lower bound for x1. We conclude that riis an increasing
series, and in particular, x2> x2
1. This last inequality and the formula for x2are especially
important as together they imply:
x1
1 + λx1
=V=1 + λx2
x1+λx1+λ2x2≥1
x1
.(9)
This holds if and only if x1≥λ
2+√4+λ2
2. Our argument also shows that x1<1
1−λ(1 + 1
√λ).
The solution satisfies x1
1+λx1→1
x1as n→ ∞.
It remains to show that for any ϵ > 0, and any large enough n, it cannot hold that x1≥
λ
2+√4+λ2
2+ϵ, and at the same time V≥1
ℓ. For this purpose, we represent the unique
x1, . . . , xnsolution as a sum of two exponentials. By solving the quadratic equation:
λ−V λ2
1 + Vz2−z+ 1 = 0,
with the roots z+> z−, and choosing Aso that: x1=Az++ (1 −A)z−,we can “roll” the
recursive relation of Eq. (5) and write for any i,
xi=Azi
++ (1 −A)zi
−.(10)
We now note that a few facts that hold true for any nwhen x1≥ℓ+ϵ:
1. z+≥1.01 ·z−.The two roots are positive whenever V≥1
ℓ, and have:
z+
z−
=p4λ2V−4λ+V+1+√V+ 1
√V+ 1 −p4λ2V−4λ+V+ 1
>1.01,
in the relevant regime. Also,
z+≥1 + V
2λ≥1 + ℓ
2λ≥ℓ
λ≥1.
27
2. A≥1
2. We can derive a direct formula for Ain terms of x1, λ when x1≥ℓ:
1
2+1 + x1−lx1
2q1+l(−4+x1)+x1
1+lx1(1 + lx1)q1+x1+lx1
1+lx1
,
which is composed of 1
2plus a positive term.
3. Finally, Eq. (6) can be restated using the exponential representation as:
(1 + V−λ−(1 −V)z+)Azn−1
++ (1 + V−λ−(1 −V)z−)(1 −A)zn−1
−= 0.
By our analysis in the first item, z+≥1, so (1 + V−λ−(1 −V)z+)A≤ −λ
2, and:
(1 + V−λ−(1 −V)z−)(1 −A)zn−1
−=−(1 + V−λ−(1 −V)z+)Azn−1
+≥λ
2zn−1
+,
i.e.,
1 + 1
1−λ(1 + 1
√λ)
λ>1 + x1
λ
≥1 + V
λ
≥1
λ(1 + V−λ−(1 −V)z−)
≥(1 + V−λ−(1 −V)z−)(1 −A)2
λ
≥(z+
z−
)n−1
≥1.01n−1.
This is a contradiction as the initial expression is a constant and the final expression
increases exponentially with n. Thus, for large enough n, either V≤1
ℓ(the upper
bound we seek), or x1< ℓ +ϵ, with arbitrarily low ϵ, therefor x1→ℓ, so V→1
ℓ.
Claim 4.4. For any ℓ, let Ξ(ℓ) = max ℓ, 1+ℓλ
ℓ,1 + λ3, then RℓIB ≥1
Ξ(ℓ).
Proof. Fix some arbitrary value of ℓ, and some adversary ψ. Consider an optimal allocation
algorithm x′for this adversary as compared with x=ℓIB. For a given index i, if both
algorithms choose a transaction with the same TTL which arrives from ψ(i)(rather than
the mempool), they must choose the same one (the highest available for this TTL).
If x′chooses at index ia transaction that is available to ℓIB (i.e., it is in µℓIB (i)), but
ℓIB does not choose it, then it must be that ℓIB chooses a transaction with a higher fee,
or the best urgent transaction which pays a fee that is at least 1
ℓas high as the fee paid by
the one chosen by x′. Denote the set of indices where the latter happens by I0.
If x′chooses a transaction at some index i0∈I0that is not available to ℓIB (i.e., it is
not in µℓIB (i0)), then it must have been chosen by ℓIB at a previous index i1. If at index i1,
28
x′chooses a transaction that is not available to ℓIB, then it must have been chosen by ℓIB
at a previous index i2, and so on. Consider a series of indices i0, i1, . . . that is constructed
recursively in the same manner. Since the index i0is a non-negative integer, and as the
series is monotonically decreasing: i0> i1> i2> . . . , there must be some index ikwhere
x′chooses a transaction that is available to ℓIB. Let i0
def
=i, and denote the recursively
constructed “chain” of indices by C={ik, . . . , i0}.
First, notice that since for 0≤j≤k−1the allocation of ℓIB at index ij+1 is the same
as the allocation of x′at index ij, we have, similarly to Eq. (3):
X
0≤j≤k−1
α(ij)λijϕ(x′(ψ(ij)∪µx′(ij))) ≤λX
1≤j≤k
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij))).(11)
We find a bound for ϕ(x′(ψ(ik)∪µx′(ik))) by splitting into cases:
1. If x′(ψ(ik)∪µx′(ik)) has TTL = 1, then since it is also available to ℓIB, the best urgent
transaction must pay a fee at least as high as paid by x′(ψ(ik)∪µx′(ik)). However,
ℓIB chooses at step ika higher TTL transaction, as it is later chosen at ik−1by x′.
We conclude that ℓIB chooses the highest fee transaction at ik, so it must satisfy:
ϕ(x′(ψ(ik)∪µx′(ik))) ≤ϕ(ℓIB(ψ(ik)∪µℓI B(ik)))
ℓ,
and thus overall:
X
0≤j≤k
α(ij)λijϕ(x′(ψ(ij)∪µ(ij))) ≤λX
1≤j≤k
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij)))
+1
ℓα(ik)λikϕ(ℓIB(ψ(ij)∪µℓI B(ik)))
≤(1
ℓ+λ)X
1≤j≤k
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij)))
=1 + ℓλ
ℓX
1≤j≤k
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij))).
2. If x′(ψ(ik)∪µ(ik)) has T T L > 1and ik−1−ik≥3, then Eq. (11) can be strengthened:
X
0≤j≤k−1
α(ij)λijϕ(x′(ψ(ij)∪µx′(ij))) ≤λ3X
1≤j≤k
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij)))
(12)
This implies:
k−1
X
j=0
α(ij)λijϕ(x′(ψ(ij)∪µx′(ij))) + α(ik)λikϕ(x′(ψ(ik)∪µx′(ik)))
≤(1 + λ3)
k
X
j=1
α(ij)λijϕ(ℓIB(ψ(ij)∪µℓI B(ij)))
29
3. If x′(ψ(ik)∪µ(ik)) has T T L > 1and ik−1=ik+ 1 (the indices are consecutive), let:
x=ϕ(x′(ψ(ik)∪µ(ik)))
z=ϕ(x′(ψ(ik−1)∪µ(ik−1)))
x′chooses xbefore zin the schedule, while it is possible for it to choose zand then
x. We know that z≥xby our definition of the chain that ends when ℓIB chooses
a higher-fee transaction then OPT (at index ik). If z > x, then z+λx > x +λz,
in contradiction to x′optimality against the adversary. If z=x, and since zhas
T T L > 1it is available to ℓIB at step ik−1. At each step of the chain, ℓIB chooses a
non TTL = 1 transaction, and so its choice at ik−1must be its highest-fee available
transaction. But, then its choice is equal to that of x′at step ik−1, and the chain
should end there and not continue backward to ik.
4. If x′(ψ(ik)∪µ(ik)) has T T L > 1and ik−1=ik+2 (i.e., there is exactly one transaction
between the two indices), then similarly to before, its TTL is at most 2, or x′could
better rearrange its choice. Since 1< T T L ≤2, we conclude that TTL = 2. As in the
previous case, denote the choice of x′at ikas x, the choice of x′at ik−1as z, and also
denote its choice at ik+ 1 (the in-between step) as y. We separate to several subcases.
•If xis not available to ℓIB at step ik+ 1, then it must have been chosen at the
latest at some step i≤ik−1. Assume that xis larger than OPT’s choice at the
step where ℓIB chooses it. Then it is not part of a chain (if it was part of a chain
and larger than OPT’s choice it would be the same chain as ik, but that chain
ends at ik). We can thus “attach” it to the analysis of the chain without interfering
in another chain’s analysis. Denote OPT’s choice at step ias s. Since all the
elements of OP T in the chain besides s, x, and zwere also chosen by ℓIB at an
earlier step, they can only increase the competitive ratio, and so we can ignore
them for the analysis. We are left with a ratio which is at most x+λik−i·z
s+λik−i·x+λ2+ik−i·z
This is minimized with i=ik−1, s =z=x, yielding: 1+λ
1+λ+λ3≥1
1+λ3.
•If xis not available to ℓIB at step ik+ 1, then it must have been chosen at
the latest at some step i≤ik−1. Assume that xis smaller than OPT’s choice
at the step where ℓIB chooses it, then the options are it is either a TTL = 1
transaction as in case (1) (but then it cannot be later chosen by OPT, so this case
is impossible), or it is at index i0of a chain. Notice that in our analysis of chains
we always ignore ℓIB’s chosen transaction at step i0, since it only increases the
competitive ratio and is not required for attaining the bounds. Thus, we can
append it to the chain that we’re analyzing without affecting the analysis of the
chain it is a part of. We then get a strict domination of ℓIB performance in our
chain: Every transaction chosen by OPT is preceded by the same transaction
chosen by ℓIB, which yields a ratio of over 1.
•If ycomes from the mempool, i.e., is already available to x′at ik, then y≤x
(by the same rearrangement argument we previously used). We know that xis
available to ℓIB at step ik+ 1. If xor a higher TTL = 1 transaction is chosen
by ℓIB at this step, then step ik+ 1 is not part of some chain (as ℓI B choices in
30
a chain are always with T T L > 1), and so we can “attach” it to the analysis of
the chain without interfering in another chain’s analysis. Let:
w=1
λ3X
0≤j≤k−2
α(ij)λijϕ(x′(ψ(ij)∪µ(ij))).
Then, over the path of the chain ℓIB gets at least:
α(ik)λik·z+α(ik+ 1)λik+1x+1
λw,
Moreover, x′gets at most
α(ik)λik·x+α(ik+ 1)λik+1y+α(ik−1)λik−1·z+w,
where dividing the first expression by the latter yields a ratio of at least
z+λx +λ2·w
x+λy +λ2z+λ3·w,
with the constraint that z≥x≥y, w ≥0. This expression is minimized with
z=x=yand w= 0, where it becomes
1 + λ
1 + λ+λ2≥min{1
1 + λ3,1
ℓ}.
•If ycomes from the mempool, i.e., is already available to x′at ik, then y≤x
(by the same rearrangement argument we previously used). We know that xis
available to ℓIB at step ik+ 1. If no TTL = 1 transaction is chosen by ℓIB at
this step, then the highest-fee transaction Mwith fee at least ℓ·xis chosen by
it, where recall that x≥y, the choice of x′at this step. Similarly to the previous
step, this would guarantee a ratio better than 1
1+λ3. However, in this case, it is
possible that ik+1 is itself part of a chain, and we need to avoid double accounting
of it. Notice however that in this case ik+ 1 is the earliest part of this chain, and
the chain is of the type characterized in the first case (1), and since ik+ 2 = ik−1
is part of the original chain, then the second-earliest link of the ik+ 1 chain is
at least ik+ 3, which strengthens the guarantee of case (1) to ℓ
1+ℓλ2. Joining the
two chains together, and letting w=1
λ3P0≤j≤k−2α(ij)λijϕ(x′(ψ(ij)∪µ(ij))),
we have that ℓIB gets at least α(ik)λik·z+α(ik+ 1)λik+1 ·M+1
λw, while x′
gets at most α(ik)λik·x+α(ik+ 1)λik+1 1+λ2ℓ
ℓ·M+α(ik−1)λik−1·z+w, where
dividing the first expression by the latter yields a ratio of at least
z+λM +λ2·w
x+λ1+λ2ℓ
ℓ·M+λ2z+λ3·w,
with the constraints M≥ℓ·x, z ≥x≥y, w ≥0. The respective coefficients of
w, M, z in the numerator and denominator yield a ratio that is at least as high
as previous guarantees, and so the expression can only yield a worst guarantee if
w, M, z are minimized, i.e., when M=ℓx, w = 0, z =x. The expression is then:
1 + λℓ
1 + λ(1 + λ2ℓ) + λ2=1 + λℓ
1 + λ+λ2+λ3ℓ≥min{1
1 + λ3,1
ℓ}.
31
•If ydoes not come from the mempool, then we cannot use a rearrangement
argument to show that y≤x. Also, yis available both to x′and ℓIB at step
ik+ 1. If either y≤x, or that its TTL at step ik+ 1 is 1, the arguments of the
previous subcases still hold, and so we consider only y > x with T T L > 1(which
also implies by a rearrangement argument that y≥z, where we recall that zis
the choice of x′at ik−1). If yis not chosen at step ik+ 1, and since we may
assume its TTL at this step is at least 2, it will then be available to ℓIB at step
ik−1=ik+ 2, which contradicts that ik−1is part of the chain and ℓIB chooses
its highest-fee available transaction there, as it chooses a transaction lower than
z(and so lower than y). We conclude that ℓIB must choose yat step ik+ 1.
If ℓIB chooses y, then we have that the ratio is at least z+λy
x+λy+λ2zwith y≥z≥x,
and so this is at least as high as 1+λ
1+λ+λ2≥min{1
1+λ3,1
ℓ}.
We consider chains Cwhere the opening pair falls into cases 1,2and 4, grouped by the
index sets C1,C2and C4respectively. In all other cases, ℓI B chooses a transaction with a fee
higher than x′. Let k(C)be the length of some chain C, and iC
jthe j-th index of a chain
C. Let Odenote the set of all such remaining indices. We conclude that:
max
x′u(x′|ψ) = X
i∈I0
α(i)λix′(ψ(i)∪µx′(i))
+X
1≤s≤|C1|
k(Cs)
X
j=0
α(iCs
j)λiCs
jx′(ψ(iCs
j)∪µx′(iCs
j))
+X
1≤s′≤|C2|
k(Cs′)
X
j=0
α(iCs′
j)λiCs′
jx′(ψ(iCs′
j)∪µx′(iCs′
j))
+X
i∈O
α(i)λix′(ψ(i)∪µx′(i))
≤ℓX
i∈I0
α(i)λiℓIB(ψ(i)∪µℓI B(i))
+1 + ℓλ
ℓX
1≤s≤|C1|
k(Cs)
X
j=0
α(iCs
j)λiCs
jℓIB(ψ(iCs
j)∪µℓIB (iCs
j))
+ (1 + λ3)X
1≤s′≤|C2|
k(Cs′)
X
j=0
α(iCs′
j)λiCs′
jℓIB(ψ(iCs′
j)∪µℓIB (iCs′
j))
+ max{1 + λ3, ℓ}X
1≤s′≤|C4|
k(Cs′)
X
j=0
α(iCs′
j)λiCs′
jℓIB(ψ(iCs′
j)∪µℓIB (iCs′
j))
+X
i∈O
α(i)λiℓIB(ψ(i)∪µℓI B(i))
≤max{ℓ, 1 + λℓ
ℓ,1 + λ2}u(ℓIB|ψ)
32
Step
0 1 2 3 ...
Transaction (TTL, fee)
ψ(0)
(1,1)
(2, ℓ −ϵ)
ψ(1)
(1,1)
(2, ℓ −ϵ)
.
.
.
←Broadcast
→Expiration
x′
ℓIB
Figure 8: The first adversary used in the proof of Claim 4.6.
Claim 4.6. For any ℓ, let Ξ(ℓ) = max{ℓ, 1+λ+λ2ℓ+λ3
1+λℓ ,1+ℓλ
ℓ,maxn≥1P2n
i=0 λi
Pn+1
i=0 λi}, then:
RℓIB ≥1
Ξ(ℓ).
Proof. Consider the adversary ∀i≥0, ψ(i) = {(1,1),(2, ℓ −ϵ)}, which is depicted in Fig. 8.
Given this adversary, ℓI B has a utility of u(ℓIB|ψ) = 1 + α·P∞
i=1 λi. Furthermore, the
allocation algorithm x′that chooses (2, ℓ −ϵ)at every step achieves a discounted utility
equal to u(x′|ψ)=(ℓ−ϵ)·(1 + αP∞
i=1 λi)=(ℓ−ϵ)u(ℓIB|ψ).
Consider the adversary ψ(0) = ∅, ψ(1) = {(1,1),(2, ℓ +ϵ)},∀i≥2 : ψ(i) = ∅. Then the
allocation algorithm x′that chooses (1,1) at round 1and (2, ℓ +ϵ)at round 2obtains a
utility of u(x′|ψ) = α·(λ+ (ℓ+ϵ)λ2) = 1+(ℓ+ϵ)λ
ℓ+ϵ·(αλ(ℓ+ϵ)) = 1+(ℓ+ϵ)λ
ℓ+ϵu(ℓIB|ψ).
Notice that if we choose ℓ=1
2(λ+pλ2+ 4), the above two bounds also follow from the
general deterministic upper bound of Theorem 4.1.
Consider the adversary ψnthat has ψn(0) = ∅,∀1≤i≤n, ψn(i) = {(n+ 2,1 + ϵ),(n+
2−i, 1)},∀i≥n+ 1, ψn(i) = ∅. Then the allocation algorithm x′that chooses the lowest
fee transaction at each round has u(x′|ψn) = αλPn
i=1 λi−1+P2n
i=n+1 λi−1(1 + ϵ), while
u(ℓIB|ψn) = αλPn
i=1 λi−1(1 + ϵ) + λn+1.
Consider the adversary ψ(0) = ∅, ψ(1) = {(4,1),(1, ϵ),(2,1−ϵ)}, ψ(2) = {(2, ℓ +
ϵ),(1,1)}. Then the algorithm x′that chooses (2,1−ϵ)at round 1,(1,1) at round 2,(2, ℓ +ϵ)
at round 3and (4,1) at round 4has revenue arbitrarily close to u(x′|ψ) = 1 + λ+λ2ℓ+λ3,
while u(ℓIB|ψ) = 1 + λℓ.
Theorem 5.1. Given α= 0, for any (possibly randomized) allocation algorithm ALG:
RALG ≥1−λ
4
33
Proof. Consider the set of fixed adversaries Φn={ψi}n
i=1.ψiare defined inductively: ψ1
with ψ1(0) = ∅, ψ1(1) = {(1,1),(2,2
2−λ)},∀j > 1, ψ1(j) = ∅. Then, ∀n≥i > 1,∀j <
i, ψi(j) = ψi−1(j), ψi(i) = {(1,(2
2−λ)i−1),(2,(2
2−λ)i),∀j > i, ψi(j) = ∅. Due to the “nest-
ing”, ALG’s performance against adversaries in Φnis defined by the series of probabilities
p1, . . . , pn, where piis the probability that ALG chooses a TTL = 1 transaction at step i.
We now use Φnto define our adaptive adversary ψn
adapt. At any step i, if pi>1
2, the
adversary chooses the TTL = 2 transaction, and otherwise if pi≤1
2, chooses the TTL = 1
one. In the latter case, if ALG chooses the TTL = 2 transaction (which happens w.p. 1−pi),
the adversary does not add transactions to the mempool, i.e., the adversary is finalized to
be ψi, and at step i+ 1 the adversary chooses the remaining TTL = 1 transaction. If no
such step ihappens before i=n, then the adversary terminates with ψn. If pn>1
2and
the adversary chooses the TTL = 2 transaction at step nwhile ALG chooses the TTL = 1
transaction, the adversary adds a transaction (1,(2
2−λ)i)at step n+ 1 and chooses it.
We now compare ALG and ADV ’s performance in different steps along the adversary
schedule, separating the steps before nand the last two steps.
Step i<n.
Examine each one separately:
•The expected performance of ALG is: (2
2−λ)i−1pi+ (1 −pi)2
2−λ.
•The expected performance of ADV at steps i, and possibly i+ 1 if step iis a termi-
nal step, when i<nand pi≤1
2is: (2
2−λ)i−11 + (1 −pi)λ2
2−λ.Notice that this
amortization of considering the i+ 1 is only relevant for ADV , as ALG in such case
necessarily has no transactions remaining to choose from at step i+ 1.
•The expected performance of ADV at step i<nif pi>1
2is: (2
2−λ)i.
For i<n, we first consider pi>1
2:
E[ϕADV (ψ(i)∪µADV (i))] = ( 2
2−λ)i
= ( 2
2−λ)i−1·2
2−λ
=2
2−λ
i−1
(1
2+1
2−λ)
2
2−λ
1
2+1
2−λ
=2
2−λ
i−1(pi+ (1 −pi)2
2−λ)+(1
2−pi+ (1
2−(1 −pi)) 2
2−λ)2
2−λ
1
2+1
2−λ
=4
4−λ·E[ϕALG(ψ(i)∪µALG (i))] + ( 2
2−λ)i−1(pi−1
2)λ
2−λ)4
4−λ.
For pi≤1
2, we have:
E[ϕADV (ψ(i)∪µADV (i))] + (1 −pi)E[ϕADV (ψ(i+ 1) ∪µAD V (i+ 1))] = ( 2
2−λ)i−11 + (1 −pi)λ2
2−λ
34
And then, one can calculate:
(2
2−λ)i−11 + (1 −pi)λ2
2−λ= ( 2
2−λ)i−1pi+ (1 −pi)2
2−λ1 + (1 −pi)λ2
2−λ
pi+ (1 −pi)2
2−λ
=E[ϕALG(ψ(i)∪µALG (i))] ·1 + (1 −pi)λ2
2−λ
pi+ (1 −pi)2
2−λ
≥4
4−λ·E[ϕALG(ψ(i)∪µALG (i))],
where the last transition is since for any 0≤λ≤1, the expression 1+(1−pi)λ2
2−λ
pi+(1−pi)2
2−λ
under the
constraint 0≤pi≤1
2is minimized with pi=1
2, where it takes the form 4
4−λ.
We conclude from the two cases that:
EAmortized [ϕADV (ψ(i)∪µALG(i))] ≥4
4−λ·E[ϕALG(ψ(i)∪µALG (i))]
+ max{0,(2
2−λ)i−1(pi−1
2)λ
2−λ
4
4−λ}
We now analyze steps n, n + 1, starting with the expected performance at these steps.
•The expected performance of ALG at these steps is:
(2
2−λ)n−1pn(1 + λ2
2−λ) + (1 −pn)2
2−λ
•If pn≤1
2, the expected performance of ADV at these steps is:
(2
2−λ)n−11 + λ2
2−λ
•If pn>1
2, the expected performance of ADV at these steps is:
(2
2−λ)n−12
2−λ+λ2
2−λ
Let f(pn) = ((2 −pn)pn>1
2
(1 −pn)pn≤1
2
. One can show that:
E[ϕADV (ψ(n)∪µADV (n))] + λE[ϕADV (ψ(n+ 1) ∪µADV (n+ 1))] ≥
E[ϕALG(ψ(n)∪µALG (n))] + λE[ϕALG (ψ(n+ 1) ∪µALG(n+ 1))] + λn(2
2−λ)n−1λ
2−λ·f(pn).
(13)
We next prove by backward induction that:
u(ADV |ψn
adapt)≥4
4−λu(ALG|ψn
adapt)−α(1) 2λ2
(4 −λ)(2 −λ).
35
We prove so by the inductive claim:
EAmortized [
n+1
X
i=k
α(i)λiϕADV (ψ(i)+µ(i))] ≥4
4−λE[
n+1
X
i=k
α(i)λiϕALG(ψ(i)+µ(i))]−λ
4−λα(k)( 2λ
2−λ)k.
As the base case, consider k=n. Then,
E[
n+1
X
i=n
α(i)λiϕADV (ψ(i) + µ(i))] Eq. (13)
≥α(n)λn·E[
n+1
X
i=n
α(i)λiϕALG(ψ(i) + µ(i))]
+α(n)λn(2
2−λ)n−1λ
2−λf(pn)
=4
4−λα(n)λnE[
n+1
X
i=n
α(i)λiϕALG(ψ(i) + µ(i))]
+α(n)λn(2
2−λ)n−1λ
2−λf(pn)
−λ
4−λα(n)λn(E[ϕALG(ψ(n) + µ(n))] + λE[ϕALG(ψ(n+ 1) + µ(n+ 1))])
≥4
4−λα(n)λnE[
n+1
X
i=n
α(i)λiϕALG(ψ(i) + µ(i))]
+α(n)λn(2
2−λ)n−1λ
2−λf(pn)
−λ
4−λα(n)λn(2
2−λ)n−1(2
2−λ+pnλ2
2−λ)
≥4
4−λα(n)λnE[
n+1
X
i=n
α(i)λiϕALG(ψ(i) + µ(i))]
+α(n)λn(2
2−λ)n−1λ
2−λ(f(pn)−pn)
−λ
4−λα(n)λn(2
2−λ)n−12
2−λ
≥4
4−λα(n)λnE[
n+1
X
i=n
α(i)λiϕALG(ψ(i) + µ(i))]
−λ
4−λα(n)( 2λ
2−λ)n.
For the inductive step:
EAmortized [
n+1
X
i=k
α(i)λiϕADV (ψ(i) + µ(i))] = EAmortized[α(k)λkϕADV (ψ(k) + µ(k))]
+pk·EAmortized [
n+1
X
i=k+1
α(i)λiϕADV (ψ(i) + µ(i))]
36
We can then bound this from below:
EAmortized [
n+1
X
i=k
α(i)λiϕADV (ψ(i) + µ(i))] ≥4
4−λ·E[ϕALG(ψ(k)∪µALG (k))]
+ max{0,(2
2−λ)k−1(pk−1
2)λ
2−λ
4
4−λ}
+pk·4
4−λE[
n+1
X
i=k+1
α(i)λiϕALG(ψ(i) + µ(i))]
−pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
=4
4−λE[
n+1
X
i=k
α(i)λiϕALG(ψ(i) + µ(i))]
+ max{0,2
2−λ
k−1
(pk−1
2)λ
2−λ
4
4−λ}
−pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
We thus need to show that:
max{0,2
2−λ
k−1
(pk−1
2)λ
2−λ
4
4−λ}−pk
λ
4−λα(k+1)( 2λ
2−λ)k+1 ≥ − λ
4−λα(k)( 2λ
2−λ)k.
First, consider if pk≤1
2. Then,
max{0,2
2−λ
k−1
(pk−1
2)λ
2−λ
4
4−λ} − pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1 =−pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
≥ −1
2
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
Thus, we need to show that −1
2α(k+ 1) 2λ
2−λ≥ −α(k), i.e., −λ≥λ−2. This indeed holds,
since 2≥2λ. Otherwise, consider if pk>1
2, then,
max{0,2λ
2−λ
k−1
(pk−1
2)λ
2−λ
4
4−λ} − pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
=2λ
2−λ
k
(pk−1
2)2λ
4−λ−pk
λ
4−λα(k+ 1)( 2λ
2−λ)k+1
≥λ
4−λα(k)( 2λ
2−λ)k2pk−1−pk
2λ
2−λ
It thus suffices to show 2pk−1−pk2λ
2−λ≥ −1, which holds if and only if: 2≥2λ
2−λ,which
37
holds since 4≥4λ. Consider limn→∞ u(ALG|ψn
adapt). If limn→∞ u(ALG|ψn
adapt) = ∞, then:
lim
n→∞
u(ALG|ψn
adapt)
u(ADV |ψn
adapt)≤lim
n→∞
u(ALG|ψn
adapt)
4
4−λu(ALG|ψn
adapt)−α(1) 2λ2
(4−λ)(2−λ)
= lim
n→∞
4−λ
4
u(ALG|ψn
adapt)
u(ALG|ψn
adapt)−α(1) λ2
2(2−λ)
=4−λ
4.
Otherwise, if limn→∞ u(ALG|ψn
adapt)is finite, the contribution of steps n, n + 1 to the sum
tends to zero. Thus, a similar argument for the negligence of the additive term follows.
Theorem 5.3. Given α= 0,RDISCλhas RRDISCλ≥1−e−λ
λ.
Proof. We show the proof for an oblivious adversary using a potential function argument.
However, this argument can be extended for an adaptive adversary (see [9]).
If Φis a potential function that receives a set of transactions, returns 0on the empty
set, and satisfies for any step i:RϕALG(ψ(i)∪µ(i)) ≥ϕOP T (ψ(i)∪µ(i)) + λΦ(ψ(i+ 1) ∪
µ(i+ 1)) −Φ(ψ(i)∪µ(i)),then ALG has a competitive ratio of 1
R. Proof by summation:
R
N
X
i=0
α(i)λiϕALG(ψ(i)∪µ(i))
≥
N
X
i=0 α(i)λiϕOP T (ψ(i)∪µ(i)) + λ(Φ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i)))
=
N
X
i=0
α(i)λiϕOP T (ψ(i)∪µ(i)) +
N
X
i=0
α(i)λi(λΦ(ψ(i+ 1) ∪µ(i+ 1)) −λΦ(ψ(i)∪µ(i)))
It remains to show that
N
X
i=0
α(i)λi(λΦ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i))) ≥0.
Notice that Φ(ψ(0) ∪µ(0)) = 0, and so
λΦ(ψ(1) ∪µ(1)) +
N
X
i=1
α(i)λi+1Φ(ψ(i+ 1) ∪µ(i+ 1)) −
N
X
i=1
α(i)λiΦ(ψ(i)∪µ(i))
≥
N
X
i=1
α(i)λi+1Φ(ψ(i+ 1) ∪µ(i+ 1)) −
N
X
i=2
α(i)λiΦ(ψ(i)∪µ(i))
=
N+1
X
i=2
α(i−1)λiΦ(ψ(i)∪µ(i)) −
N
X
i=2
α(i)λiΦ(ψ(i)∪µ(i))
=α(N)λN+1Φ(ψ(N+ 1) ∪µ(N+ 1)) = 0.
38
To prove the theorem statement, it thus remains to show that at every step i, there is
such a potential function Φso that:
ϕRDISCλ(ψ(i)∪µ(i)) ≥1−e−λ
λϕOP T (ψ(i)∪µ(i)) + λΦ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i)).
Let x(λ) = λ
1−e−λ. We define ϕRDISCλ=ϕRDISCλ(ψ(i)∪µ(i)), and ϕOP T =ϕOP T (ψ(i)∪
µ(i)). Theorem 3.1 of Chin et al. [11] shows that there is a potential function with:
E[ϕRDISCλ−(Φ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i)))] ≥Zlog E[ϕOP T ]
wh
−λ
1
λexwhdx,
where whis the highest transaction fee available to RDISCλat step i. The argument of
Chin et al. [11] proceeds by showing conditions that hold for any fixed x∈[−1,0], and so
they hold for any fixed x∈[−λ, 0], as well.
With this potential function, we can thus write at step i,
E[x(λ)ϕRDISCλ−(λΦ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i)))]
= (x(λ)−λ)·E[ϕRDISCλ] + λE[ϕRDISCλ−(Φ(ψ(i+ 1) ∪µ(i+ 1)) −1
λΦ(ψ(i)∪µ(i)))]
≥(x(λ)−λ)·E[ϕRDISCλ] + λE[ϕRDISCλ−(Φ(ψ(i+ 1) ∪µ(i+ 1)) −Φ(ψ(i)∪µ(i)))]
≥(x(λ)−λ)Z0
−λ
1
λexwhdx +λZlog E[ϕOP T ]
wh
−λ
1
λexwhdx
=wh·(1
1−e−λ−1)(1 −e−λ) + E[ϕOP T ]
wh−e−λ
=E[ϕOP T ].
B Modeling & Discussion
We review empirical evidence that relate to the modeling of blockchain users and miners.
B.1 Users with Diverse Patience Preferences
We show examples that demonstrate how users may have different patience levels (which
translate in our model to different deadlines).
1. It is common for blocks to contain outlier transactions that pay unnecessarily high
fees [46,53,68]. These transactions could enter the same block with much lower
fees. For example, transaction f58 . . . 5ff in Bitcoin block 000 . . . 65apays more than
double the fee of the next highest paying transaction in the block.
2. On the other hand, the number of pending transactions may grow much larger than
a single block in popular cryptocurrencies. This can only happen if transactions end
39
Mon Tue Wed Thu Fri Sat Sun
50
100
150
200
250
Day
Fees, in gwei
99th percentile
90th percentile
Average
Median
10th percentile
0 3 7 11 15 19 23
50
100
150
200
250
Hour
Fees, in gwei
99th percentile
90th percentile
Average
Median
10th percentile
Figure 9: The per-day and per-hour average fees for Ethereum transactions sent between
November 2022 and May 2023, where hours are in the UTC time zone, and fees are given
in gwei (1gwei is equal to 10−9ETH).
up underbidding for the current block. For example, in the six-month period between
January 1st, 2021, and June 1st of the same year, Bitcoin’s set of pending transactions
was consistently at least 20 times larger than a single block [48]. In Ethereum, blocks
typically contain an average of around 300 transactions, while more than 150,000 are
pending at the time of writing [21].
3. There are daily patterns to transaction fees. This can be observed in Fig. 9, which
depicts the average fees for Ethereum transactions sent between November 2022 and
May 2023. In a fully competitive market with patient users, one would expect users
to delay their transactions to times when fees are low [15].
4. Fee recommendation engines are popular among users. Such engines (e.g., [53,68])
typically receive as input the urgency with which a user wants to have its transaction
included from a predefined “menu” (e.g., low, medium, or high urgency). As output,
the engine gives some estimate of the fee which should be paid to get the transaction
accepted in a block within a timeframe corresponding to the chosen urgency.
B.2 Non-Myopic Miners
There are many examples of non-myopic mining incentives, both theoretical [17,18,62,
75] and empirical [49,53]. Furthermore, exploring the effect of non-myopic incentives is
natural, as miners may use mining equipment for a few years before recovering purchasing
costs [59,76]. These incentives can be augmented when considering the “size-advantage” of
large miners [44,47], who can expect to mine multiple blocks in a row with non-negligible
probability. Indeed, empirical data collected at the time of writing shows that a small
number of actors is involved in Ethereum’s block-building process (see Tables 3to 5, with
data collected from [57,58]). Further empirical evidence suggesting that actors are not
myopic can be found by observing the transactions included in Bitcoin and Ethereum blocks.
Sometimes, a transaction with lower fees is allocated before transactions with higher ones
40
Table 3: Ethereum’s all-time
top 25 stakers, ranked by
block share.
Name Share
Lido 27.77%
Coinbase 8.64%
Binance 6.64%
SSV 5.45%
Ether.Fi 5.24%
Kraken 2.91%
Rocketpool 1.66%
OKex 1.39%
Ledger Live 1.26%
Whale 0x5d76a 0.73%
Kiln On-Chain 0.62%
CoinSpot 0.41%
Stader 0.39%
Frax 0.32%
Liquid Collective 0.32%
Octant 0.30%
Bitstamp 0.19%
Swell 0.19%
StakeWise v2 0.18%
Bitfinex 0.16%
Puffer 0.16%
Revolut 0.15%
StakeHound 0.11%
Kucoin 0.08%
Bitget 0.07%
Table 4: Ethereum’s all-time
top 25 builders, ranked by
block share.
Name Share
Beaverbuild 35.06%
Titan Builder 21.75%
Rsync 13.12%
Flashbots 10.13%
Builder 0x69 8.81%
BloXroute 3.11%
Blocknative 1.26%
Eth-builder.com 0.92%
f1b.io 0.76%
jetbldr.xyz 0.76%
gethgo1.19.1linux 0.60%
BuildAI 0.50%
Gambit Labs 0.37%
Manta 0.35%
penguinbuild 0.30%
rpc.tbuilder.xyz 0.19%
Payload.de 0.18%
Lightspeed 0.17%
lokibuilder.xyz 0.17%
Boba Builder 0.16%
BuilderNet 0.11%
Manifold 0.10%
Eden Network 0.08%
penguinbuild.org 0.08%
Builder+ btcs.com 0.08%
Table 5: Ethereum’s top 25
builders by block share for
Jan. 15 - Feb. 15, 2025.
Name Share
Beaverbuild 47.42%
Titan Builder 42.74%
Rsync 7.59%
BuilderNet 1.31%
Builder+ btcs.com 0.22%
blockbeelder 0.16%
BuildAI 0.12%
gethgo1.20.14linux 0.10%
bobTheBuilder.xyz 0.08%
lokibuilder.xyz 0.07%
Ty For The Block 0.05%
Boba Builder 0.04%
gigabuilder.io 0.02%
I can haz block? 0.02%
BloXroute 0.02%
Builder 0x69 0.02%
jetbldr.xyz 0.01%
Gambit Labs 0.01%
smithbot.xyz 0.01%
r(sync)builder 0.00%
Manifold 0.00%
0x45 0.00%
Blank 0.00%
MevRefund-1 Bad guys-0 0.00%
Joe’s block r(sync)builder 0.00%
[49,53]. This stands in contrast with the current literature on TFM design, which assumes
actors always allocate the highest-paying transactions [8,39,60,80].
41
C Glossary
A summary of all symbols and acronyms used in the paper.
C.1 Symbols
ψTransaction schedule function.
xAllocation function.
BPredefined maximal block-size, in bytes.
λMiner discount factor.
ϕTransaction fee of some transaction, in tokens.
TMiner planning horizon.
ℓImmediacy ratio for our non-myopic allocation rule.
µTTL of past transactions.
αMiner’s relative mining power, as a fraction.
uMiner revenue.
tTTL of a transaction.
τA transaction.
C.2 Acronyms
FIFO first-in-first-out
mempool memory pool
TFM transaction fee mechanism
TTL time to live
42
