From 11cd720f454483a105c28905e1fc0c03565f0e75 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Wed, 19 Feb 2025 11:15:32 +0000 Subject: [PATCH 01/13] expand on EL changes --- EIPS/eip-7805.md | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index f0b3b4a01e32c5..47a14adf58e990 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -103,13 +103,31 @@ For each transaction `T` in ILs, perform the following: 3. Execute `T` on state `S`. Assert that the execution of `T` fails. -If `B` is full, the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. +If at any point `B` is full (i.e. less than 21000 remaining gas), the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. + +#### Engine API Changes We make the following changes to the engine API: -- Add `engine_getInclusionList` endpoint to retrieve an IL from the `ExecutionEngine` -- Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer -- Modify `engine_forkchoiceUpdated` endpoint to include a field in the payload attributes for transactions in ILs determined by the proposer +- Add `engine_getInclusionListV1` endpoint to retrieve an IL from the `ExecutionEngine`. +- Add `engine_updatePayloadWithInclusionListV1` endpoint to update the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. +- Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer. If the IL is not satisfied an `INVALID_INCLUSION_LIST` error must be returned. + +The IL is always encoded as an array of RLP encoded transactions in hex form. + +The full Engine API changes can be found in the [Execution APIs](https://github.com/ethereum/execution-apis/blob/58b019ea5ee4a84d9767402145b9a88789f0359e/src/engine/experimental/eip7805.md) GitHub repository. + +#### IL Building + +The IL should be built using the following rules: + +First order all transactions from the pool by priority fee, and then by timestamp in the event of a tie. For each transaction `T` in the sorted list: + +1. If adding `T` would make the IL exceed `MAX_BYTES_PER_INCLUSION_LIST` then skip this transaction. + +2. Otherwise add this transaction to the IL. + +3. If there is less than `100` bytes remaining then the IL is considered full and the process terminates. ### Consensus Layer From 7021f78c8e5ca9f0f280cf25ec884e670a42371f Mon Sep 17 00:00:00 2001 From: Marc Date: Thu, 20 Feb 2025 10:40:37 +0000 Subject: [PATCH 02/13] Update EIPS/eip-7805.md Co-authored-by: JihoonSong --- EIPS/eip-7805.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 47a14adf58e990..2863279a213fda 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -110,7 +110,7 @@ If at any point `B` is full (i.e. less than 21000 remaining gas), the process te We make the following changes to the engine API: - Add `engine_getInclusionListV1` endpoint to retrieve an IL from the `ExecutionEngine`. -- Add `engine_updatePayloadWithInclusionListV1` endpoint to update the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. +- Add `engine_updatePayloadWithInclusionListV1` endpoint to update a payload with the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. - Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer. If the IL is not satisfied an `INVALID_INCLUSION_LIST` error must be returned. The IL is always encoded as an array of RLP encoded transactions in hex form. From 805921232dc643f56517e6cd600134528acb6542 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Thu, 20 Feb 2025 10:49:41 +0000 Subject: [PATCH 03/13] move IL building to EL section, undo block full quantification --- EIPS/eip-7805.md | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 2863279a213fda..ac8a25ae93bc7e 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -40,8 +40,6 @@ This section outlines the workflow of FOCIL, detailing the roles and responsibil - **`Slot N`, `t=0 to 8s`**: IL committee members construct their ILs by including transactions pending in the public mempool, and broadcast them over the P2P network after processing the block for `slot N` and confirming it as the head. If no block is received by `t=7s`, they should run `get_head` and build and release their ILs based on the node’s local head. - By default, ILs are built by selecting raw transactions from the public mempool, ordered by priority fees, up to the IL’s maximum size in bytes of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB` per IL. Additional rules can be optionally applied to maximize censorship resistance, such as prioritizing valid transactions that have been pending in the mempool the longest. - #### Validators - **`Slot N`, `t=0s to 9s`**: Validators receive ILs from the P2P network and store (1) all new ILs that pass the CL P2P validation rules, and (2) any evidence of IL equivocation by committee members (i.e., if multiple ILs are received from the same committee member). @@ -103,7 +101,7 @@ For each transaction `T` in ILs, perform the following: 3. Execute `T` on state `S`. Assert that the execution of `T` fails. -If at any point `B` is full (i.e. less than 21000 remaining gas), the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. +If at any point `B` is full, the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. #### Engine API Changes @@ -119,15 +117,7 @@ The full Engine API changes can be found in the [Execution APIs](https://github. #### IL Building -The IL should be built using the following rules: - -First order all transactions from the pool by priority fee, and then by timestamp in the event of a tie. For each transaction `T` in the sorted list: - -1. If adding `T` would make the IL exceed `MAX_BYTES_PER_INCLUSION_LIST` then skip this transaction. - -2. Otherwise add this transaction to the IL. - -3. If there is less than `100` bytes remaining then the IL is considered full and the process terminates. +By default, ILs are built by selecting raw transactions from the public mempool, ordered by priority fees, up to the IL’s maximum size in bytes of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB` per IL. Additional rules can be optionally applied to maximize censorship resistance, such as prioritizing valid transactions that have been pending in the mempool the longest. Implementations are free to choose their own ordering rules. ### Consensus Layer From 1bb8e943fd4d3eba409058577dedec704206c985 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Thu, 20 Feb 2025 10:51:27 +0000 Subject: [PATCH 04/13] undo more on block full --- EIPS/eip-7805.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index ac8a25ae93bc7e..f4c98585e1b505 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -101,7 +101,7 @@ For each transaction `T` in ILs, perform the following: 3. Execute `T` on state `S`. Assert that the execution of `T` fails. -If at any point `B` is full, the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. +If `B` is full, the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. #### Engine API Changes From 534d586723a45327d6ff3a958ed2d4350c966136 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Sat, 22 Feb 2025 10:33:24 +0000 Subject: [PATCH 05/13] remove txs being hex encoded --- EIPS/eip-7805.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index f4c98585e1b505..7dc13505283143 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -111,8 +111,6 @@ We make the following changes to the engine API: - Add `engine_updatePayloadWithInclusionListV1` endpoint to update a payload with the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. - Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer. If the IL is not satisfied an `INVALID_INCLUSION_LIST` error must be returned. -The IL is always encoded as an array of RLP encoded transactions in hex form. - The full Engine API changes can be found in the [Execution APIs](https://github.com/ethereum/execution-apis/blob/58b019ea5ee4a84d9767402145b9a88789f0359e/src/engine/experimental/eip7805.md) GitHub repository. #### IL Building From 1b461a689104226e279d8600e20c2979b4e2f457 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Sat, 22 Feb 2025 10:38:43 +0000 Subject: [PATCH 06/13] rewrite IL building to be up to implementer --- EIPS/eip-7805.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 7dc13505283143..94452af770693f 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -115,7 +115,7 @@ The full Engine API changes can be found in the [Execution APIs](https://github. #### IL Building -By default, ILs are built by selecting raw transactions from the public mempool, ordered by priority fees, up to the IL’s maximum size in bytes of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB` per IL. Additional rules can be optionally applied to maximize censorship resistance, such as prioritizing valid transactions that have been pending in the mempool the longest. Implementations are free to choose their own ordering rules. +The rules for building ILs are left up to the implementers discretion. Possible strategies include randomly choosing from the transaction pool, ordering by priority fee, time spent pending in the mempool, etc. ### Consensus Layer From fabb2adacbd6621ce37d9771c1bb0f022f4dabba Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Sat, 22 Feb 2025 14:43:29 +0000 Subject: [PATCH 07/13] block is no invalid but will be reorged --- EIPS/eip-7805.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 94452af770693f..d18cade493f0cb 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -83,8 +83,7 @@ When validators receive ILs from the P2P network, they perform a series of valid ### Execution Layer -On the execution layer, the block validity conditions are extended such that, after all of the transactions in the block have been executed, we attempt to execute each valid transaction from ILs that was not present in the block. -If one of those transactions executes successfully, then the block is invalid. +On the execution layer, an additional check is introduced for new payloads. After all of the transactions in the payload have been executed, we attempt to execute each valid transaction from ILs that was not present in the payload. If one of those transactions executes successfully, then an error is returned to the CL. Although the block is valid the CL will not attest to it. Let `B` denote the current block. Let `S` denote the execution state following the execution of the last transaction in `B`. @@ -97,11 +96,11 @@ For each transaction `T` in ILs, perform the following: - If `T` is invalid, then continue to the next transaction. - - If `T` is valid, terminate process and assert block `B` as invalid. + - If `T` is valid, terminate process and return an error. 3. Execute `T` on state `S`. Assert that the execution of `T` fails. -If `B` is full, the process terminates. Also note that we do not need to reset the state to `S`, since the only way for a transaction to alter the state is for it to execute successfully, in which case the block is invalid, and so the block will not be applied to the state. +If `B` is full, the process terminates. Also note that the state `S` must be restored if a transaction from the IL is successfully applied to it. #### Engine API Changes From 1a5f22f8fea4aff856a3f9c996ff7eea289c4e7d Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Sat, 22 Feb 2025 14:48:09 +0000 Subject: [PATCH 08/13] reword --- EIPS/eip-7805.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index d18cade493f0cb..03f7fe8c128e08 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -100,7 +100,7 @@ For each transaction `T` in ILs, perform the following: 3. Execute `T` on state `S`. Assert that the execution of `T` fails. -If `B` is full, the process terminates. Also note that the state `S` must be restored if a transaction from the IL is successfully applied to it. +If `B` is full, the process terminates. Also note that the state `S` must be restored if a transaction from the IL is successfully executed against it. #### Engine API Changes From a4a546bb45b0b693ec6466845eb2a4527c492ae5 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Sat, 22 Feb 2025 15:22:56 +0000 Subject: [PATCH 09/13] IL building strategy --- EIPS/eip-7805.md | 49 ++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 47 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 03f7fe8c128e08..2a8894fbcbc971 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -40,6 +40,8 @@ This section outlines the workflow of FOCIL, detailing the roles and responsibil - **`Slot N`, `t=0 to 8s`**: IL committee members construct their ILs by including transactions pending in the public mempool, and broadcast them over the P2P network after processing the block for `slot N` and confirming it as the head. If no block is received by `t=7s`, they should run `get_head` and build and release their ILs based on the node’s local head. +Each committee member is assigned an id from `0` to `f`. + #### Validators - **`Slot N`, `t=0s to 9s`**: Validators receive ILs from the P2P network and store (1) all new ILs that pass the CL P2P validation rules, and (2) any evidence of IL equivocation by committee members (i.e., if multiple ILs are received from the same committee member). @@ -106,7 +108,7 @@ If `B` is full, the process terminates. Also note that the state `S` must be res We make the following changes to the engine API: -- Add `engine_getInclusionListV1` endpoint to retrieve an IL from the `ExecutionEngine`. +- Add `engine_getInclusionListV1` endpoint to retrieve an IL from the `ExecutionEngine`. It takes as an argument the IL committee member id. - Add `engine_updatePayloadWithInclusionListV1` endpoint to update a payload with the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. - Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer. If the IL is not satisfied an `INVALID_INCLUSION_LIST` error must be returned. @@ -114,7 +116,49 @@ The full Engine API changes can be found in the [Execution APIs](https://github. #### IL Building -The rules for building ILs are left up to the implementers discretion. Possible strategies include randomly choosing from the transaction pool, ordering by priority fee, time spent pending in the mempool, etc. +Implementers are recommended to use the following algorithm to build ILs: + +```python +def build_inclusion_list(committee_member_id, pending_transactions): + random.shuffle(pending_transactions) + + main_bucket = [tx for tx in pending_transactions if tx.hash.starts_with(committee_member_id)] + other_buckets = [tx for tx in pending_transactions if not tx.hash.starts_with(committee_member_id)] + + size = 0 + il = [] + while True: + next_tx = get_next_tx(main_bucket, other_buckets) + if not next_tx: + break + if size + next_tx.size() > MAX_BYTES_PER_INCLUSION_LIST: + continue + else: + size += next_tx.size() + il.append(next_tx) + + return il + +def get_next_tx(main_bucket, other_buckets): + if random.random() < PICK_OTHER_BUCKET: + if len(other_buckets) > 0: + return other_buckets.pop() + elif len(main_buckets) > 0: + return main_buckets.pop() + else + return None + else + if len(main_bucket) > 0: + return main_bucket.pop() + elif len(other_buckets) > 0: + return other_buckets.pop() + else + return None +``` + +This algorithm should serve as a base that can be tweaked by different implementations. These tweaks could, for example, modify the value of `PICK_OTHER_BUCKET`, or weight the random shuffle based on priority fees or time spent pending in the mempool. Diversity of IL building algorithms can strengthen censorship resistance. + +Note that randomness should be generated in a cryptographically secure way with a local entropy source. ### Consensus Layer @@ -134,6 +178,7 @@ The full consensus changes can be found in the following GitHub repository. They | `DOMAIN_IL_COMMITTEE` | `DomainType('0x0C000000')` | | `IL_COMMITTEE_SIZE` | `uint64(2**4)` (=16) | | `MAX_BYTES_PER_INCLUSION_LIST` | `uint64(2**13)` (=8192) | +| `PICK_OTHER_BUCKET` | `float(0.1)` | ##### New containers From 3053382b0bfdc9b976d2690d41bd38d23fa5e257 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Mon, 24 Feb 2025 10:40:59 +0000 Subject: [PATCH 10/13] introduce IL building in earlier section --- EIPS/eip-7805.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 03f7fe8c128e08..afea36fcae07a6 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -40,6 +40,8 @@ This section outlines the workflow of FOCIL, detailing the roles and responsibil - **`Slot N`, `t=0 to 8s`**: IL committee members construct their ILs by including transactions pending in the public mempool, and broadcast them over the P2P network after processing the block for `slot N` and confirming it as the head. If no block is received by `t=7s`, they should run `get_head` and build and release their ILs based on the node’s local head. +IL committee members may follow different strategies for constructing their ILs as discussed in [IL Building](#il-building). + #### Validators - **`Slot N`, `t=0s to 9s`**: Validators receive ILs from the P2P network and store (1) all new ILs that pass the CL P2P validation rules, and (2) any evidence of IL equivocation by committee members (i.e., if multiple ILs are received from the same committee member). From b7b4d11140adea8894939d15f0248a363800d7a3 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Mon, 24 Feb 2025 22:11:48 +0000 Subject: [PATCH 11/13] comments --- EIPS/eip-7805.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index afea36fcae07a6..8b894f7fbaa491 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -109,14 +109,14 @@ If `B` is full, the process terminates. Also note that the state `S` must be res We make the following changes to the engine API: - Add `engine_getInclusionListV1` endpoint to retrieve an IL from the `ExecutionEngine`. -- Add `engine_updatePayloadWithInclusionListV1` endpoint to update a payload with the IL that should be used to build the block. This takes as an argument an 8 byte `payloadId` of the ongoing payload build process, along with the IL itself. +- Add `engine_updatePayloadWithInclusionListV1` endpoint to update a payload with the IL that should be used to build the block. This takes as an argument an 8-byte `payloadId` of the ongoing payload build process, along with the IL itself. - Modify `engine_newPayload` endpoint to include a parameter for transactions in ILs determined by the proposer. If the IL is not satisfied an `INVALID_INCLUSION_LIST` error must be returned. The full Engine API changes can be found in the [Execution APIs](https://github.com/ethereum/execution-apis/blob/58b019ea5ee4a84d9767402145b9a88789f0359e/src/engine/experimental/eip7805.md) GitHub repository. #### IL Building -The rules for building ILs are left up to the implementers discretion. Possible strategies include randomly choosing from the transaction pool, ordering by priority fee, time spent pending in the mempool, etc. +The rules for building ILs are left to the discretion of implementers. For instance, they may select transactions from the public mempool in various ways such as at random, by priority fee, or based on how long they have been pending. This process continues until the IL reaches its maximum size of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB`. ### Consensus Layer From a749628c9d5c2177e799365cf07622a884e92299 Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Mon, 24 Feb 2025 23:10:50 +0000 Subject: [PATCH 12/13] reword algorithm to suggestion to use nondeterminism and bias --- EIPS/eip-7805.md | 55 +++++++++--------------------------------------- 1 file changed, 10 insertions(+), 45 deletions(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index e5b4961cc722f9..937a3685eac3bb 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -40,10 +40,10 @@ This section outlines the workflow of FOCIL, detailing the roles and responsibil - **`Slot N`, `t=0 to 8s`**: IL committee members construct their ILs by including transactions pending in the public mempool, and broadcast them over the P2P network after processing the block for `slot N` and confirming it as the head. If no block is received by `t=7s`, they should run `get_head` and build and release their ILs based on the node’s local head. -Each committee member is assigned an id from `0` to `f`. - IL committee members may follow different strategies for constructing their ILs as discussed in [IL Building](#il-building). +Each committee member is assigned an id from `0` to `f`. This is derived from the validator index, the lowest validator index is mapped to `0` and the highest to `f`. + #### Validators - **`Slot N`, `t=0s to 9s`**: Validators receive ILs from the P2P network and store (1) all new ILs that pass the CL P2P validation rules, and (2) any evidence of IL equivocation by committee members (i.e., if multiple ILs are received from the same committee member). @@ -119,51 +119,16 @@ The full Engine API changes can be found in the [Execution APIs](https://github. #### IL Building -Implementers are recommended to use the following algorithm to build ILs: - -```python -def build_inclusion_list(committee_member_id, pending_transactions): - random.shuffle(pending_transactions) - - main_bucket = [tx for tx in pending_transactions if tx.hash.starts_with(committee_member_id)] - other_buckets = [tx for tx in pending_transactions if not tx.hash.starts_with(committee_member_id)] - - size = 0 - il = [] - while True: - next_tx = get_next_tx(main_bucket, other_buckets) - if not next_tx: - break - if size + next_tx.size() > MAX_BYTES_PER_INCLUSION_LIST: - continue - else: - size += next_tx.size() - il.append(next_tx) - - return il - -def get_next_tx(main_bucket, other_buckets): - if random.random() < PICK_OTHER_BUCKET: - if len(other_buckets) > 0: - return other_buckets.pop() - elif len(main_buckets) > 0: - return main_buckets.pop() - else - return None - else - if len(main_bucket) > 0: - return main_bucket.pop() - elif len(other_buckets) > 0: - return other_buckets.pop() - else - return None -``` - -This algorithm should serve as a base that can be tweaked by different implementations. These tweaks could, for example, modify the value of `PICK_OTHER_BUCKET`, or weight the random shuffle based on priority fees or time spent pending in the mempool. Diversity of IL building algorithms can strengthen censorship resistance. +The rules for building ILs are left to the discretion of implementers; a diverse set of strategies can strengthen censorship resistance. Transactions from the public mempool could be selected based on several factors such as: -Note that randomness should be generated in a cryptographically secure way with a local entropy source. +- Time spent pending in the mempool. +- Nondeterminism: Introducing randomness can reduce overlap between ILs, leading to a larger IL when they are combined. +- Bias: Picking some transactions more often than others in order to further reduce overlap between ILs. This should be done based on committee member id, for example the member with id `a` may be more likely to pick transactions with hashes that start with `a`. +- Priority fee. +- Byte size: prioritising smaller transactions. +- The number of times a transaction has been included in reorged payloads. -The rules for building ILs are left to the discretion of implementers. For instance, they may select transactions from the public mempool in various ways such as at random, by priority fee, or based on how long they have been pending. This process continues until the IL reaches its maximum size of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB`. +The selection process continues until the IL reaches its maximum size of `MAX_BYTES_PER_INCLUSION_LIST = 8 KiB`. ### Consensus Layer From 104d5d08c658c0665bc855458147159ef4f8e39b Mon Sep 17 00:00:00 2001 From: Marc Harvey-Hill Date: Mon, 24 Feb 2025 23:33:04 +0000 Subject: [PATCH 13/13] remove unused constant --- EIPS/eip-7805.md | 1 - 1 file changed, 1 deletion(-) diff --git a/EIPS/eip-7805.md b/EIPS/eip-7805.md index 937a3685eac3bb..425a22343695c9 100644 --- a/EIPS/eip-7805.md +++ b/EIPS/eip-7805.md @@ -148,7 +148,6 @@ The full consensus changes can be found in the following GitHub repository. They | `DOMAIN_IL_COMMITTEE` | `DomainType('0x0C000000')` | | `IL_COMMITTEE_SIZE` | `uint64(2**4)` (=16) | | `MAX_BYTES_PER_INCLUSION_LIST` | `uint64(2**13)` (=8192) | -| `PICK_OTHER_BUCKET` | `float(0.1)` | ##### New containers