diff --git a/beacon_node/beacon_chain/src/beacon_chain.rs b/beacon_node/beacon_chain/src/beacon_chain.rs
index 56d1ab4d438..38ee40bf592 100644
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -5690,48 +5690,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     execution_payload_value,
                 )
             }
-            BeaconState::Gloas(_) => {
-                let (
-                    payload,
-                    kzg_commitments,
-                    maybe_blobs_and_proofs,
-                    maybe_requests,
-                    execution_payload_value,
-                ) = block_contents
-                    .ok_or(BlockProductionError::MissingExecutionPayload)?
-                    .deconstruct();
-
-                (
-                    BeaconBlock::Gloas(BeaconBlockGloas {
-                        slot,
-                        proposer_index,
-                        parent_root,
-                        state_root: Hash256::zero(),
-                        body: BeaconBlockBodyGloas {
-                            randao_reveal,
-                            eth1_data,
-                            graffiti,
-                            proposer_slashings: proposer_slashings.into(),
-                            attester_slashings: attester_slashings_electra.into(),
-                            attestations: attestations_electra.into(),
-                            deposits: deposits.into(),
-                            voluntary_exits: voluntary_exits.into(),
-                            sync_aggregate: sync_aggregate
-                                .ok_or(BlockProductionError::MissingSyncAggregate)?,
-                            execution_payload: payload
-                                .try_into()
-                                .map_err(|_| BlockProductionError::InvalidPayloadFork)?,
-                            bls_to_execution_changes: bls_to_execution_changes.into(),
-                            blob_kzg_commitments: kzg_commitments
-                                .ok_or(BlockProductionError::InvalidPayloadFork)?,
-                            execution_requests: maybe_requests
-                                .ok_or(BlockProductionError::MissingExecutionRequests)?,
-                        },
-                    }),
-                    maybe_blobs_and_proofs,
-                    execution_payload_value,
-                )
-            }
+            BeaconState::Gloas(_) => todo!("Gloas block production"),
         };
 
         let block = SignedBeaconBlock::from_block(
diff --git a/beacon_node/beacon_chain/src/test_utils.rs b/beacon_node/beacon_chain/src/test_utils.rs
index 9a463e1a85c..f7551b7c658 100644
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
@@ -3258,25 +3258,6 @@ pub fn generate_rand_block_and_blobs<E: EthSpec>(
             message.body.blob_kzg_commitments = bundle.commitments.clone();
             bundle
         }
-        SignedBeaconBlock::Gloas(SignedBeaconBlockGloas {
-            ref mut message, ..
-        }) => {
-            // Get either zero blobs or a random number of blobs between 1 and Max Blobs.
-            let payload: &mut FullPayloadGloas<E> = &mut message.body.execution_payload;
-            let num_blobs = match num_blobs {
-                NumBlobs::Random => rng.gen_range(1..=max_blobs),
-                NumBlobs::Number(n) => n,
-                NumBlobs::None => 0,
-            };
-            let (bundle, transactions) =
-                execution_layer::test_utils::generate_blobs::<E>(num_blobs, fork_name).unwrap();
-            payload.execution_payload.transactions = <_>::default();
-            for tx in Vec::from(transactions) {
-                payload.execution_payload.transactions.push(tx).unwrap();
-            }
-            message.body.blob_kzg_commitments = bundle.commitments.clone();
-            bundle
-        }
         _ => return (block, blob_sidecars),
     };
 
diff --git a/beacon_node/execution_layer/src/engine_api.rs b/beacon_node/execution_layer/src/engine_api.rs
index a638feebe56..ad6a1837a7e 100644
--- a/beacon_node/execution_layer/src/engine_api.rs
+++ b/beacon_node/execution_layer/src/engine_api.rs
@@ -541,34 +541,6 @@ impl<E: EthSpec> ExecutionPayloadBodyV1<E> {
                     ))
                 }
             }
-            ExecutionPayloadHeader::Gloas(header) => {
-                if let Some(withdrawals) = self.withdrawals {
-                    Ok(ExecutionPayload::Gloas(ExecutionPayloadGloas {
-                        parent_hash: header.parent_hash,
-                        fee_recipient: header.fee_recipient,
-                        state_root: header.state_root,
-                        receipts_root: header.receipts_root,
-                        logs_bloom: header.logs_bloom,
-                        prev_randao: header.prev_randao,
-                        block_number: header.block_number,
-                        gas_limit: header.gas_limit,
-                        gas_used: header.gas_used,
-                        timestamp: header.timestamp,
-                        extra_data: header.extra_data,
-                        base_fee_per_gas: header.base_fee_per_gas,
-                        block_hash: header.block_hash,
-                        transactions: self.transactions,
-                        withdrawals,
-                        blob_gas_used: header.blob_gas_used,
-                        excess_blob_gas: header.excess_blob_gas,
-                    }))
-                } else {
-                    Err(format!(
-                        "block {} is post capella but payload body doesn't have withdrawals",
-                        header.block_hash
-                    ))
-                }
-            }
         }
     }
 }
diff --git a/beacon_node/execution_layer/src/engine_api/new_payload_request.rs b/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
index 64f71307a5c..a3b6f48ba2b 100644
--- a/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
+++ b/beacon_node/execution_layer/src/engine_api/new_payload_request.rs
@@ -172,6 +172,7 @@ impl<'block, E: EthSpec> NewPayloadRequest<'block, E> {
     }
 }
 
+//TODO(EIP7732): Consider implmenting these as methods on the NewPayloadRequest struct
 impl<'a, E: EthSpec> TryFrom<BeaconBlockRef<'a, E>> for NewPayloadRequest<'a, E> {
     type Error = BeaconStateError;
 
@@ -220,17 +221,7 @@ impl<'a, E: EthSpec> TryFrom<BeaconBlockRef<'a, E>> for NewPayloadRequest<'a, E>
                 parent_beacon_block_root: block_ref.parent_root,
                 execution_requests: &block_ref.body.execution_requests,
             })),
-            BeaconBlockRef::Gloas(block_ref) => Ok(Self::Gloas(NewPayloadRequestGloas {
-                execution_payload: &block_ref.body.execution_payload.execution_payload,
-                versioned_hashes: block_ref
-                    .body
-                    .blob_kzg_commitments
-                    .iter()
-                    .map(kzg_commitment_to_versioned_hash)
-                    .collect(),
-                parent_beacon_block_root: block_ref.parent_root,
-                execution_requests: &block_ref.body.execution_requests,
-            })),
+            BeaconBlockRef::Gloas(_) => Err(Self::Error::IncorrectStateVariant),
         }
     }
 }
@@ -251,11 +242,15 @@ impl<'a, E: EthSpec> TryFrom<ExecutionPayloadRef<'a, E>> for NewPayloadRequest<'
             ExecutionPayloadRef::Deneb(_) => Err(Self::Error::IncorrectStateVariant),
             ExecutionPayloadRef::Electra(_) => Err(Self::Error::IncorrectStateVariant),
             ExecutionPayloadRef::Fulu(_) => Err(Self::Error::IncorrectStateVariant),
+            //TODO(EIP7732): Probably time to just get rid of this
             ExecutionPayloadRef::Gloas(_) => Err(Self::Error::IncorrectStateVariant),
         }
     }
 }
 
+// TODO(EIP-7732) build out the following when it's needed like in Mark's branch
+// impl<'a, E: EthSpec> TryFrom<ExecutionEnvelopeRef<'a, E>> for NewPayloadRequest<E> {
+
 #[cfg(test)]
 mod test {
     use crate::versioned_hashes::Error as VersionedHashError;
diff --git a/beacon_node/execution_layer/src/lib.rs b/beacon_node/execution_layer/src/lib.rs
index 12e68244647..7f04f31a473 100644
--- a/beacon_node/execution_layer/src/lib.rs
+++ b/beacon_node/execution_layer/src/lib.rs
@@ -55,8 +55,8 @@ use types::{
 };
 use types::{
     BeaconStateError, BlindedPayload, ChainSpec, Epoch, ExecPayload, ExecutionPayloadBellatrix,
-    ExecutionPayloadCapella, ExecutionPayloadElectra, ExecutionPayloadFulu, ExecutionPayloadGloas,
-    FullPayload, ProposerPreparationData, PublicKeyBytes, Signature, Slot,
+    ExecutionPayloadCapella, ExecutionPayloadElectra, ExecutionPayloadFulu, FullPayload,
+    ProposerPreparationData, PublicKeyBytes, Signature, Slot,
 };
 
 mod block_hash;
@@ -131,13 +131,6 @@ impl<E: EthSpec> TryFrom<BuilderBid<E>> for ProvenancedPayload<BlockProposalCont
                 blobs_and_proofs: None,
                 requests: Some(builder_bid.execution_requests),
             },
-            BuilderBid::Gloas(builder_bid) => BlockProposalContents::PayloadAndBlobs {
-                payload: ExecutionPayloadHeader::Gloas(builder_bid.header).into(),
-                block_value: builder_bid.value,
-                kzg_commitments: builder_bid.blob_kzg_commitments,
-                blobs_and_proofs: None,
-                requests: Some(builder_bid.execution_requests),
-            },
         };
         Ok(ProvenancedPayload::Builder(
             BlockProposalContentsType::Blinded(block_proposal_contents),
@@ -1356,6 +1349,7 @@ impl<E: EthSpec> ExecutionLayer<E> {
     }
 
     /// Maps to the `engine_newPayload` JSON-RPC call.
+    /// TODO(EIP-7732) figure out how and why Mark relaxed new_payload_request param's typ to NewPayloadRequest<E>
     pub async fn notify_new_payload(
         &self,
         new_payload_request: NewPayloadRequest<'_, E>,
@@ -1828,10 +1822,12 @@ impl<E: EthSpec> ExecutionLayer<E> {
                 ForkName::Deneb => ExecutionPayloadDeneb::default().into(),
                 ForkName::Electra => ExecutionPayloadElectra::default().into(),
                 ForkName::Fulu => ExecutionPayloadFulu::default().into(),
-                ForkName::Gloas => ExecutionPayloadGloas::default().into(),
                 ForkName::Base | ForkName::Altair => {
                     return Err(Error::InvalidForkForPayload);
                 }
+                ForkName::Gloas => {
+                    return Err(Error::InvalidForkForPayload);
+                }
             };
             return Ok(Some(payload));
         }
diff --git a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
index adc6c3f84c2..386109de738 100644
--- a/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
+++ b/beacon_node/execution_layer/src/test_utils/execution_block_generator.rs
@@ -908,12 +908,8 @@ pub fn generate_genesis_header<E: EthSpec>(
             *header.transactions_root_mut() = empty_transactions_root;
             Some(header)
         }
-        ForkName::Gloas => {
-            let mut header = ExecutionPayloadHeader::Gloas(<_>::default());
-            *header.block_hash_mut() = genesis_block_hash.unwrap_or_default();
-            *header.transactions_root_mut() = empty_transactions_root;
-            Some(header)
-        }
+        // TODO(EIP-7732): need to look into this
+        ForkName::Gloas => None,
     }
 }
 
diff --git a/beacon_node/execution_layer/src/test_utils/mock_builder.rs b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
index 05ca9776a6a..50a3479c574 100644
--- a/beacon_node/execution_layer/src/test_utils/mock_builder.rs
+++ b/beacon_node/execution_layer/src/test_utils/mock_builder.rs
@@ -27,7 +27,7 @@ use tracing::{debug, error, info, warn};
 use tree_hash::TreeHash;
 use types::builder_bid::{
     BuilderBid, BuilderBidBellatrix, BuilderBidCapella, BuilderBidDeneb, BuilderBidElectra,
-    BuilderBidFulu, BuilderBidGloas, SignedBuilderBid,
+    BuilderBidFulu, SignedBuilderBid,
 };
 use types::{
     Address, BeaconState, ChainSpec, Epoch, EthSpec, ExecPayload, ExecutionPayload,
@@ -115,9 +115,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.fee_recipient = fee_recipient;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.fee_recipient = fee_recipient;
-            }
         }
     }
 
@@ -138,9 +135,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.gas_limit = gas_limit;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.gas_limit = gas_limit;
-            }
         }
     }
 
@@ -165,9 +159,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.parent_hash = ExecutionBlockHash::from_root(parent_hash);
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.parent_hash = ExecutionBlockHash::from_root(parent_hash);
-            }
         }
     }
 
@@ -188,9 +179,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.prev_randao = prev_randao;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.prev_randao = prev_randao;
-            }
         }
     }
 
@@ -211,9 +199,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.block_number = block_number;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.block_number = block_number;
-            }
         }
     }
 
@@ -234,9 +219,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.timestamp = timestamp;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.timestamp = timestamp;
-            }
         }
     }
 
@@ -257,9 +239,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
             ExecutionPayloadHeaderRefMut::Fulu(header) => {
                 header.withdrawals_root = withdrawals_root;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.withdrawals_root = withdrawals_root;
-            }
         }
     }
 
@@ -293,10 +272,6 @@ impl<E: EthSpec> BidStuff<E> for BuilderBid<E> {
                 header.extra_data = extra_data;
                 header.block_hash = ExecutionBlockHash::from_root(header.tree_hash_root());
             }
-            ExecutionPayloadHeaderRefMut::Gloas(header) => {
-                header.extra_data = extra_data;
-                header.block_hash = ExecutionBlockHash::from_root(header.tree_hash_root());
-            }
         }
     }
 }
@@ -482,8 +457,9 @@ impl<E: EthSpec> MockBuilder<E> {
             SignedBlindedBeaconBlock::Fulu(block) => {
                 block.message.body.execution_payload.tree_hash_root()
             }
-            SignedBlindedBeaconBlock::Gloas(block) => {
-                block.message.body.execution_payload.tree_hash_root()
+            SignedBlindedBeaconBlock::Gloas(_) => {
+                // TODO(EIP7732) Check if this is how we want to do error handling for gloas
+                return Err("invalid fork".to_string());
             }
         };
         info!(
@@ -568,18 +544,10 @@ impl<E: EthSpec> MockBuilder<E> {
                 ) = payload_response.into();
 
                 match fork {
-                    ForkName::Gloas => BuilderBid::Gloas(BuilderBidGloas {
-                        header: payload
-                            .as_gloas()
-                            .map_err(|_| "incorrect payload variant".to_string())?
-                            .into(),
-                        blob_kzg_commitments: maybe_blobs_bundle
-                            .map(|b| b.commitments.clone())
-                            .unwrap_or_default(),
-                        value: self.get_bid_value(value),
-                        pubkey: self.builder_sk.public_key().compress(),
-                        execution_requests: maybe_requests.unwrap_or_default(),
-                    }),
+                    ForkName::Gloas => {
+                        // TODO(EIP7732) Check if this is how we want to do error handling for gloas
+                        return Err("invalid fork".to_string());
+                    }
                     ForkName::Fulu => BuilderBid::Fulu(BuilderBidFulu {
                         header: payload
                             .as_fulu()
diff --git a/beacon_node/store/src/partial_beacon_state.rs b/beacon_node/store/src/partial_beacon_state.rs
index cbdbb7eec0f..a3154d3629d 100644
--- a/beacon_node/store/src/partial_beacon_state.rs
+++ b/beacon_node/store/src/partial_beacon_state.rs
@@ -115,11 +115,9 @@ where
         partial_getter(rename = "latest_execution_payload_header_fulu")
     )]
     pub latest_execution_payload_header: ExecutionPayloadHeaderFulu<E>,
-    #[superstruct(
-        only(Gloas),
-        partial_getter(rename = "latest_execution_payload_header_gloas")
-    )]
-    pub latest_execution_payload_header: ExecutionPayloadHeaderGloas<E>,
+
+    #[superstruct(only(Gloas), partial_getter(rename = "latest_execution_bid_gloas"))]
+    pub latest_execution_bid: ExecutionBid,
 
     // Capella
     #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas))]
@@ -154,6 +152,23 @@ where
     pub pending_consolidations: List<PendingConsolidation, E::PendingConsolidationsLimit>,
     #[superstruct(only(Fulu, Gloas))]
     pub proposer_lookahead: Vector<u64, E::ProposerLookaheadSlots>,
+
+    // Gloas
+    #[superstruct(only(Gloas))]
+    pub execution_payload_availability: BitVector<E::SlotsPerHistoricalRoot>,
+
+    #[superstruct(only(Gloas))]
+    pub builder_pending_payments: Vector<BuilderPendingPayment, E::BuilderPendingPaymentsLimit>,
+
+    #[superstruct(only(Gloas))]
+    pub builder_pending_withdrawals:
+        List<BuilderPendingWithdrawal, E::BuilderPendingWithdrawalsLimit>,
+
+    #[superstruct(only(Gloas))]
+    pub latest_block_hash: ExecutionBlockHash,
+
+    #[superstruct(only(Gloas))]
+    pub latest_withdrawals_root: Hash256,
 }
 
 impl<E: EthSpec> PartialBeaconState<E> {
@@ -466,7 +481,7 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
                     current_sync_committee,
                     next_sync_committee,
                     inactivity_scores,
-                    latest_execution_payload_header,
+                    latest_execution_bid,
                     next_withdrawal_index,
                     next_withdrawal_validator_index,
                     deposit_requests_start_index,
@@ -478,7 +493,12 @@ impl<E: EthSpec> TryInto<BeaconState<E>> for PartialBeaconState<E> {
                     pending_deposits,
                     pending_partial_withdrawals,
                     pending_consolidations,
-                    proposer_lookahead
+                    proposer_lookahead,
+                    execution_payload_availability,
+                    builder_pending_payments,
+                    builder_pending_withdrawals,
+                    latest_block_hash,
+                    latest_withdrawals_root
                 ],
                 [historical_summaries]
             ),
diff --git a/consensus/state_processing/src/genesis.rs b/consensus/state_processing/src/genesis.rs
index 88ef79310dc..b8657676fd8 100644
--- a/consensus/state_processing/src/genesis.rs
+++ b/consensus/state_processing/src/genesis.rs
@@ -167,9 +167,8 @@ pub fn initialize_beacon_state_from_eth1<E: EthSpec>(
         state.fork_mut().previous_version = spec.gloas_fork_version;
 
         // Override latest execution payload header.
-        if let Some(ExecutionPayloadHeader::Gloas(header)) = execution_payload_header {
-            *state.latest_execution_payload_header_gloas_mut()? = header.clone();
-        }
+        // Here's where we *would* clone the header but there is no header here so..
+        // TODO(EIP7732): check this
     }
 
     // Now that we have our validators, initialize the caches (including the committees)
diff --git a/consensus/state_processing/src/per_block_processing.rs b/consensus/state_processing/src/per_block_processing.rs
index 88da640f94a..df489d5a6aa 100644
--- a/consensus/state_processing/src/per_block_processing.rs
+++ b/consensus/state_processing/src/per_block_processing.rs
@@ -40,7 +40,6 @@ mod verify_exit;
 mod verify_proposer_slashing;
 
 use crate::common::decrease_balance;
-
 use crate::common::update_progressive_balances_cache::{
     initialize_progressive_balances_cache, update_progressive_balances_metrics,
 };
@@ -170,10 +169,14 @@ pub fn per_block_processing<E: EthSpec, Payload: AbstractExecPayload<E>>(
     // previous block.
     if is_execution_enabled(state, block.body()) {
         let body = block.body();
+        // TODO(EIP-7732): build out process_withdrawals variant for gloas
         process_withdrawals::<E, Payload>(state, body.execution_payload()?, spec)?;
         process_execution_payload::<E, Payload>(state, body, spec)?;
     }
 
+    // TODO(EIP-7732): build out process_execution_bid
+    // process_execution_bid(state, block, verify_signatures, spec)?;
+
     process_randao(state, block, verify_randao, ctxt, spec)?;
     process_eth1_data(state, block.body().eth1_data())?;
     process_operations(state, block.body(), verify_signatures, ctxt, spec)?;
@@ -450,12 +453,6 @@ pub fn process_execution_payload<E: EthSpec, Payload: AbstractExecPayload<E>>(
                 _ => return Err(BlockProcessingError::IncorrectStateType),
             }
         }
-        ExecutionPayloadHeaderRefMut::Gloas(header_mut) => {
-            match payload.to_execution_payload_header() {
-                ExecutionPayloadHeader::Gloas(header) => *header_mut = header,
-                _ => return Err(BlockProcessingError::IncorrectStateType),
-            }
-        }
     }
 
     Ok(())
@@ -467,6 +464,7 @@ pub fn process_execution_payload<E: EthSpec, Payload: AbstractExecPayload<E>>(
 /// repeatedly write code to treat these errors as false.
 /// https://github.com/ethereum/consensus-specs/blob/dev/specs/bellatrix/beacon-chain.md#is_merge_transition_complete
 pub fn is_merge_transition_complete<E: EthSpec>(state: &BeaconState<E>) -> bool {
+    // TODO(EIP7732): check this cause potuz modified this function for god knows what reason
     if state.fork_name_unchecked().capella_enabled() {
         true
     } else if state.fork_name_unchecked().bellatrix_enabled() {
@@ -630,6 +628,7 @@ pub fn get_expected_withdrawals<E: EthSpec>(
 }
 
 /// Apply withdrawals to the state.
+/// TODO(EIP-7732): abstract this out and create gloas variant
 pub fn process_withdrawals<E: EthSpec, Payload: AbstractExecPayload<E>>(
     state: &mut BeaconState<E>,
     payload: Payload::Ref<'_>,
diff --git a/consensus/state_processing/src/upgrade/gloas.rs b/consensus/state_processing/src/upgrade/gloas.rs
index 8bb6991bfbe..e1ca954e117 100644
--- a/consensus/state_processing/src/upgrade/gloas.rs
+++ b/consensus/state_processing/src/upgrade/gloas.rs
@@ -1,5 +1,9 @@
+use bls::Hash256;
 use std::mem;
-use types::{BeaconState, BeaconStateError as Error, BeaconStateGloas, ChainSpec, EthSpec, Fork};
+use types::{
+    BeaconState, BeaconStateError as Error, BeaconStateGloas, BitVector, BuilderPendingPayment,
+    ChainSpec, EthSpec, ExecutionBid, Fork, List, Vector,
+};
 
 /// Transform a `Fulu` state into a `Gloas` state.
 pub fn upgrade_to_gloas<E: EthSpec>(
@@ -63,8 +67,8 @@ pub fn upgrade_state_to_gloas<E: EthSpec>(
         // Sync committees
         current_sync_committee: pre.current_sync_committee.clone(),
         next_sync_committee: pre.next_sync_committee.clone(),
-        // Execution
-        latest_execution_payload_header: pre.latest_execution_payload_header.upgrade_to_gloas(),
+        // Execution Bid
+        latest_execution_bid: ExecutionBid::default(),
         // Capella
         next_withdrawal_index: pre.next_withdrawal_index,
         next_withdrawal_validator_index: pre.next_withdrawal_validator_index,
@@ -79,6 +83,15 @@ pub fn upgrade_state_to_gloas<E: EthSpec>(
         pending_deposits: pre.pending_deposits.clone(),
         pending_partial_withdrawals: pre.pending_partial_withdrawals.clone(),
         pending_consolidations: pre.pending_consolidations.clone(),
+        // Gloas
+        execution_payload_availability: BitVector::default(), // All bits set to false initially
+        builder_pending_payments: Vector::new(vec![
+            BuilderPendingPayment::default();
+            E::builder_pending_withdrawals_limit()
+        ])?,
+        builder_pending_withdrawals: List::default(), // Empty list initially,
+        latest_block_hash: pre.latest_execution_payload_header.block_hash,
+        latest_withdrawals_root: Hash256::default(),
         // Caches
         total_active_balance: pre.total_active_balance,
         progressive_balances_cache: mem::take(&mut pre.progressive_balances_cache),
diff --git a/consensus/types/src/beacon_block.rs b/consensus/types/src/beacon_block.rs
index b984e791ce7..e2c71b77e98 100644
--- a/consensus/types/src/beacon_block.rs
+++ b/consensus/types/src/beacon_block.rs
@@ -672,15 +672,41 @@ impl<E: EthSpec, Payload: AbstractExecPayload<E>> EmptyBlock for BeaconBlockGloa
                 deposits: VariableList::empty(),
                 voluntary_exits: VariableList::empty(),
                 sync_aggregate: SyncAggregate::empty(),
-                execution_payload: Payload::Gloas::default(),
                 bls_to_execution_changes: VariableList::empty(),
-                blob_kzg_commitments: VariableList::empty(),
-                execution_requests: ExecutionRequests::default(),
+                signed_execution_bid: SignedExecutionBid::empty(),
+                payload_attestations: VariableList::empty(),
+                _phantom: PhantomData,
             },
         }
     }
 }
 
+/// TODO(EIP-7732) Mark's branch had the following implementation but not sure if it's needed so will just add header below for reference
+// impl<E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockEIP7732<E, Payload> {
+
+// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas
+impl<E: EthSpec> From<BeaconBlockGloas<E, BlindedPayload<E>>>
+    for BeaconBlockGloas<E, FullPayload<E>>
+{
+    fn from(block: BeaconBlockGloas<E, BlindedPayload<E>>) -> Self {
+        let BeaconBlockGloas {
+            slot,
+            proposer_index,
+            parent_root,
+            state_root,
+            body,
+        } = block;
+
+        BeaconBlockGloas {
+            slot,
+            proposer_index,
+            parent_root,
+            state_root,
+            body: body.into(),
+        }
+    }
+}
+
 // We can convert pre-Bellatrix blocks without payloads into blocks "with" payloads.
 impl<E: EthSpec> From<BeaconBlockBase<E, BlindedPayload<E>>>
     for BeaconBlockBase<E, FullPayload<E>>
diff --git a/consensus/types/src/beacon_block_body.rs b/consensus/types/src/beacon_block_body.rs
index 1db2a2f7169..f0fea0501e3 100644
--- a/consensus/types/src/beacon_block_body.rs
+++ b/consensus/types/src/beacon_block_body.rs
@@ -127,17 +127,18 @@ pub struct BeaconBlockBody<E: EthSpec, Payload: AbstractExecPayload<E> = FullPay
     #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))]
     #[serde(flatten)]
     pub execution_payload: Payload::Fulu,
-    #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))]
-    #[serde(flatten)]
-    pub execution_payload: Payload::Gloas,
     #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas))]
     pub bls_to_execution_changes:
         VariableList<SignedBlsToExecutionChange, E::MaxBlsToExecutionChanges>,
-    #[superstruct(only(Deneb, Electra, Fulu, Gloas))]
+    #[superstruct(only(Deneb, Electra, Fulu))]
     pub blob_kzg_commitments: KzgCommitments<E>,
-    #[superstruct(only(Electra, Fulu, Gloas))]
+    #[superstruct(only(Electra, Fulu))]
     pub execution_requests: ExecutionRequests<E>,
-    #[superstruct(only(Base, Altair))]
+    #[superstruct(only(Gloas))]
+    pub signed_execution_bid: SignedExecutionBid,
+    #[superstruct(only(Gloas))]
+    pub payload_attestations: VariableList<PayloadAttestation<E>, E::MaxPayloadAttestations>,
+    #[superstruct(only(Base, Altair, Gloas))]
     #[metastruct(exclude_from(fields))]
     #[ssz(skip_serializing, skip_deserializing)]
     #[tree_hash(skip_hashing)]
@@ -166,7 +167,7 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
             Self::Deneb(body) => Ok(Payload::Ref::from(&body.execution_payload)),
             Self::Electra(body) => Ok(Payload::Ref::from(&body.execution_payload)),
             Self::Fulu(body) => Ok(Payload::Ref::from(&body.execution_payload)),
-            Self::Gloas(body) => Ok(Payload::Ref::from(&body.execution_payload)),
+            Self::Gloas(_) => Err(Error::IncorrectStateVariant),
         }
     }
 
@@ -224,16 +225,19 @@ impl<'a, E: EthSpec, Payload: AbstractExecPayload<E>> BeaconBlockBodyRef<'a, E,
 
     /// Produces the proof of inclusion for a `KzgCommitment` in `self.blob_kzg_commitments`
     /// at `index` using an existing proof for the `blob_kzg_commitments` field.
+    /// TODO(EIP7732) Investigate calling functions since this will no longer work for glas since no block_kzg_commitments in the body anymore
     pub fn complete_kzg_commitment_merkle_proof(
         &self,
         index: usize,
         kzg_commitments_proof: &[Hash256],
     ) -> Result<FixedVector<Hash256, E::KzgCommitmentInclusionProofDepth>, Error> {
         match self {
-            Self::Base(_) | Self::Altair(_) | Self::Bellatrix(_) | Self::Capella(_) => {
-                Err(Error::IncorrectStateVariant)
-            }
-            Self::Deneb(_) | Self::Electra(_) | Self::Fulu(_) | Self::Gloas(_) => {
+            Self::Base(_)
+            | Self::Altair(_)
+            | Self::Bellatrix(_)
+            | Self::Capella(_)
+            | Self::Gloas(_) => Err(Error::IncorrectStateVariant),
+            Self::Deneb(_) | Self::Electra(_) | Self::Fulu(_) => {
                 // We compute the branches by generating 2 merkle trees:
                 // 1. Merkle tree for the `blob_kzg_commitments` List object
                 // 2. Merkle tree for the `BeaconBlockBody` container
@@ -512,6 +516,46 @@ impl<E: EthSpec> From<BeaconBlockBodyAltair<E, BlindedPayload<E>>>
     }
 }
 
+// Post-Fulu block bodies without payloads can be converted into block bodies with payloads
+// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas
+impl<E: EthSpec> From<BeaconBlockBodyGloas<E, BlindedPayload<E>>>
+    for BeaconBlockBodyGloas<E, FullPayload<E>>
+{
+    fn from(body: BeaconBlockBodyGloas<E, BlindedPayload<E>>) -> Self {
+        let BeaconBlockBodyGloas {
+            randao_reveal,
+            eth1_data,
+            graffiti,
+            proposer_slashings,
+            attester_slashings,
+            attestations,
+            deposits,
+            voluntary_exits,
+            sync_aggregate,
+            bls_to_execution_changes,
+            signed_execution_bid,
+            payload_attestations,
+            _phantom,
+        } = body;
+
+        BeaconBlockBodyGloas {
+            randao_reveal,
+            eth1_data,
+            graffiti,
+            proposer_slashings,
+            attester_slashings,
+            attestations,
+            deposits,
+            voluntary_exits,
+            sync_aggregate,
+            bls_to_execution_changes,
+            signed_execution_bid,
+            payload_attestations,
+            _phantom: PhantomData,
+        }
+    }
+}
+
 // Likewise bodies with payloads can be transformed into bodies without.
 impl<E: EthSpec> From<BeaconBlockBodyBase<E, FullPayload<E>>>
     for (
@@ -822,10 +866,10 @@ impl<E: EthSpec> From<BeaconBlockBodyGloas<E, FullPayload<E>>>
             deposits,
             voluntary_exits,
             sync_aggregate,
-            execution_payload: FullPayloadGloas { execution_payload },
             bls_to_execution_changes,
-            blob_kzg_commitments,
-            execution_requests,
+            signed_execution_bid,
+            payload_attestations,
+            _phantom,
         } = body;
 
         (
@@ -839,14 +883,12 @@ impl<E: EthSpec> From<BeaconBlockBodyGloas<E, FullPayload<E>>>
                 deposits,
                 voluntary_exits,
                 sync_aggregate,
-                execution_payload: BlindedPayloadGloas {
-                    execution_payload_header: From::from(&execution_payload),
-                },
                 bls_to_execution_changes,
-                blob_kzg_commitments: blob_kzg_commitments.clone(),
-                execution_requests,
+                signed_execution_bid,
+                payload_attestations,
+                _phantom: PhantomData,
             },
-            Some(execution_payload),
+            None,
         )
     }
 }
@@ -1046,39 +1088,8 @@ impl<E: EthSpec> BeaconBlockBodyFulu<E, FullPayload<E>> {
 
 impl<E: EthSpec> BeaconBlockBodyGloas<E, FullPayload<E>> {
     pub fn clone_as_blinded(&self) -> BeaconBlockBodyGloas<E, BlindedPayload<E>> {
-        let BeaconBlockBodyGloas {
-            randao_reveal,
-            eth1_data,
-            graffiti,
-            proposer_slashings,
-            attester_slashings,
-            attestations,
-            deposits,
-            voluntary_exits,
-            sync_aggregate,
-            execution_payload: FullPayloadGloas { execution_payload },
-            bls_to_execution_changes,
-            blob_kzg_commitments,
-            execution_requests,
-        } = self;
-
-        BeaconBlockBodyGloas {
-            randao_reveal: randao_reveal.clone(),
-            eth1_data: eth1_data.clone(),
-            graffiti: *graffiti,
-            proposer_slashings: proposer_slashings.clone(),
-            attester_slashings: attester_slashings.clone(),
-            attestations: attestations.clone(),
-            deposits: deposits.clone(),
-            voluntary_exits: voluntary_exits.clone(),
-            sync_aggregate: sync_aggregate.clone(),
-            execution_payload: BlindedPayloadGloas {
-                execution_payload_header: execution_payload.into(),
-            },
-            bls_to_execution_changes: bls_to_execution_changes.clone(),
-            blob_kzg_commitments: blob_kzg_commitments.clone(),
-            execution_requests: execution_requests.clone(),
-        }
+        let (block_body, _payload) = self.clone().into();
+        block_body
     }
 }
 
diff --git a/consensus/types/src/beacon_state.rs b/consensus/types/src/beacon_state.rs
index 6c6352a37fa..92514fdbca4 100644
--- a/consensus/types/src/beacon_state.rs
+++ b/consensus/types/src/beacon_state.rs
@@ -515,14 +515,9 @@ where
     )]
     #[metastruct(exclude_from(tree_lists))]
     pub latest_execution_payload_header: ExecutionPayloadHeaderFulu<E>,
-    #[superstruct(
-        only(Gloas),
-        partial_getter(rename = "latest_execution_payload_header_gloas")
-    )]
+    #[superstruct(only(Gloas))]
     #[metastruct(exclude_from(tree_lists))]
-    pub latest_execution_payload_header: ExecutionPayloadHeaderGloas<E>,
-
-    // Capella
+    pub latest_execution_bid: ExecutionBid,
     #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
     #[metastruct(exclude_from(tree_lists))]
@@ -580,6 +575,31 @@ where
     pub proposer_lookahead: Vector<u64, E::ProposerLookaheadSlots>,
 
     // Gloas
+    #[test_random(default)]
+    #[superstruct(only(Gloas))]
+    #[metastruct(exclude_from(tree_lists))]
+    pub execution_payload_availability: BitVector<E::SlotsPerHistoricalRoot>,
+
+    #[compare_fields(as_iter)]
+    #[test_random(default)]
+    #[superstruct(only(Gloas))]
+    pub builder_pending_payments: Vector<BuilderPendingPayment, E::BuilderPendingPaymentsLimit>,
+
+    #[compare_fields(as_iter)]
+    #[test_random(default)]
+    #[superstruct(only(Gloas))]
+    pub builder_pending_withdrawals:
+        List<BuilderPendingWithdrawal, E::BuilderPendingWithdrawalsLimit>,
+
+    #[test_random(default)]
+    #[superstruct(only(Gloas))]
+    #[metastruct(exclude_from(tree_lists))]
+    pub latest_block_hash: ExecutionBlockHash,
+
+    #[test_random(default)]
+    #[superstruct(only(Gloas))]
+    #[metastruct(exclude_from(tree_lists))]
+    pub latest_withdrawals_root: Hash256,
 
     // Caching (not in the spec)
     #[serde(skip_serializing, skip_deserializing)]
@@ -1070,9 +1090,8 @@ impl<E: EthSpec> BeaconState<E> {
             BeaconState::Fulu(state) => Ok(ExecutionPayloadHeaderRef::Fulu(
                 &state.latest_execution_payload_header,
             )),
-            BeaconState::Gloas(state) => Ok(ExecutionPayloadHeaderRef::Gloas(
-                &state.latest_execution_payload_header,
-            )),
+            // TODO(EIP-7732): investigate calling functions
+            BeaconState::Gloas(_) => Err(Error::IncorrectStateVariant),
         }
     }
 
@@ -1096,9 +1115,8 @@ impl<E: EthSpec> BeaconState<E> {
             BeaconState::Fulu(state) => Ok(ExecutionPayloadHeaderRefMut::Fulu(
                 &mut state.latest_execution_payload_header,
             )),
-            BeaconState::Gloas(state) => Ok(ExecutionPayloadHeaderRefMut::Gloas(
-                &mut state.latest_execution_payload_header,
-            )),
+            // TODO(EIP-7732): investigate calling functions
+            BeaconState::Gloas(_) => Err(Error::IncorrectStateVariant),
         }
     }
 
@@ -2103,6 +2121,21 @@ impl<E: EthSpec> BeaconState<E> {
         }
     }
 
+    pub fn is_parent_block_full(&self) -> bool {
+        match self {
+            BeaconState::Base(_) | BeaconState::Altair(_) => false,
+            // TODO(EIP-7732): check the implications of this when we get to forkchoice modifications
+            BeaconState::Bellatrix(_)
+            | BeaconState::Capella(_)
+            | BeaconState::Deneb(_)
+            | BeaconState::Electra(_)
+            | BeaconState::Fulu(_) => true,
+            BeaconState::Gloas(state) => {
+                state.latest_execution_bid.block_hash == state.latest_block_hash
+            }
+        }
+    }
+
     /// Get the committee cache for some `slot`.
     ///
     /// Return an error if the cache for the slot's epoch is not initialized.
diff --git a/consensus/types/src/builder_bid.rs b/consensus/types/src/builder_bid.rs
index 7c4b66fbd8c..daf77ead73a 100644
--- a/consensus/types/src/builder_bid.rs
+++ b/consensus/types/src/builder_bid.rs
@@ -2,9 +2,9 @@ use crate::beacon_block_body::KzgCommitments;
 use crate::{
     test_utils::TestRandom, ChainSpec, ContextDeserialize, EthSpec,
     ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb,
-    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, ExecutionPayloadHeaderGloas,
-    ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut, ExecutionRequests, ForkName,
-    ForkVersionDecode, SignedRoot, Uint256,
+    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, ExecutionPayloadHeaderRef,
+    ExecutionPayloadHeaderRefMut, ExecutionRequests, ForkName, ForkVersionDecode, SignedRoot,
+    Uint256,
 };
 use bls::PublicKeyBytes;
 use bls::Signature;
@@ -16,7 +16,7 @@ use test_random_derive::TestRandom;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Bellatrix, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             PartialEq,
@@ -49,11 +49,9 @@ pub struct BuilderBid<E: EthSpec> {
     pub header: ExecutionPayloadHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "header_fulu"))]
     pub header: ExecutionPayloadHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "header_gloas"))]
-    pub header: ExecutionPayloadHeaderGloas<E>,
-    #[superstruct(only(Deneb, Electra, Fulu, Gloas))]
+    #[superstruct(only(Deneb, Electra, Fulu))]
     pub blob_kzg_commitments: KzgCommitments<E>,
-    #[superstruct(only(Electra, Fulu, Gloas))]
+    #[superstruct(only(Electra, Fulu))]
     pub execution_requests: ExecutionRequests<E>,
     #[serde(with = "serde_utils::quoted_u256")]
     pub value: Uint256,
@@ -86,7 +84,7 @@ impl<E: EthSpec> ForkVersionDecode for BuilderBid<E> {
     /// SSZ decode with explicit fork variant.
     fn from_ssz_bytes_by_fork(bytes: &[u8], fork_name: ForkName) -> Result<Self, ssz::DecodeError> {
         let builder_bid = match fork_name {
-            ForkName::Altair | ForkName::Base => {
+            ForkName::Altair | ForkName::Base | ForkName::Gloas => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "unsupported fork for ExecutionPayloadHeader: {fork_name}",
                 )))
@@ -98,7 +96,6 @@ impl<E: EthSpec> ForkVersionDecode for BuilderBid<E> {
             ForkName::Deneb => BuilderBid::Deneb(BuilderBidDeneb::from_ssz_bytes(bytes)?),
             ForkName::Electra => BuilderBid::Electra(BuilderBidElectra::from_ssz_bytes(bytes)?),
             ForkName::Fulu => BuilderBid::Fulu(BuilderBidFulu::from_ssz_bytes(bytes)?),
-            ForkName::Gloas => BuilderBid::Gloas(BuilderBidGloas::from_ssz_bytes(bytes)?),
         };
         Ok(builder_bid)
     }
@@ -154,10 +151,7 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for BuilderBid<E> {
             ForkName::Fulu => {
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
-            ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
-            }
-            ForkName::Base | ForkName::Altair => {
+            ForkName::Base | ForkName::Altair | ForkName::Gloas => {
                 return Err(serde::de::Error::custom(format!(
                     "BuilderBid failed to deserialize: unsupported fork '{}'",
                     context
diff --git a/consensus/types/src/builder_pending_payment.rs b/consensus/types/src/builder_pending_payment.rs
new file mode 100644
index 00000000000..0beb53ac29f
--- /dev/null
+++ b/consensus/types/src/builder_pending_payment.rs
@@ -0,0 +1,35 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Default,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[context_deserialize(ForkName)]
+pub struct BuilderPendingPayment {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub weight: u64,
+    pub withdrawal: BuilderPendingWithdrawal,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(BuilderPendingPayment);
+}
diff --git a/consensus/types/src/builder_pending_withdrawal.rs b/consensus/types/src/builder_pending_withdrawal.rs
new file mode 100644
index 00000000000..951b9cad58d
--- /dev/null
+++ b/consensus/types/src/builder_pending_withdrawal.rs
@@ -0,0 +1,39 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    Clone,
+    Default,
+    Serialize,
+    Deserialize,
+    Encode,
+    Decode,
+    TreeHash,
+    TestRandom,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[context_deserialize(ForkName)]
+pub struct BuilderPendingWithdrawal {
+    #[serde(with = "serde_utils::address_hex")]
+    pub fee_recipient: Address,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub amount: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub builder_index: u64,
+    pub withdrawable_epoch: Epoch,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(BuilderPendingWithdrawal);
+}
diff --git a/consensus/types/src/chain_spec.rs b/consensus/types/src/chain_spec.rs
index 38e1c9e0cc8..f773d1478cd 100644
--- a/consensus/types/src/chain_spec.rs
+++ b/consensus/types/src/chain_spec.rs
@@ -28,6 +28,8 @@ pub enum Domain {
     SyncCommittee,
     ContributionAndProof,
     SyncCommitteeSelectionProof,
+    BeaconBuilder,
+    PTCAttester,
     ApplicationMask(ApplicationDomain),
 }
 
@@ -81,6 +83,7 @@ pub struct ChainSpec {
     pub bls_withdrawal_prefix_byte: u8,
     pub eth1_address_withdrawal_prefix_byte: u8,
     pub compounding_withdrawal_prefix_byte: u8,
+    pub builder_withdrawal_prefix_byte: u8,
 
     /*
      * Time parameters
@@ -113,6 +116,8 @@ pub struct ChainSpec {
     pub(crate) domain_voluntary_exit: u32,
     pub(crate) domain_selection_proof: u32,
     pub(crate) domain_aggregate_and_proof: u32,
+    pub(crate) domain_beacon_builder: u32,
+    pub(crate) domain_ptc_attester: u32,
 
     /*
      * Fork choice
@@ -215,6 +220,8 @@ pub struct ChainSpec {
     pub gloas_fork_version: [u8; 4],
     /// The Gloas fork epoch is optional, with `None` representing "Gloas never happens".
     pub gloas_fork_epoch: Option<Epoch>,
+    pub builder_payment_threshold_numerator: u64,
+    pub builder_payment_threshold_denominator: u64,
 
     /*
      * Networking
@@ -514,6 +521,8 @@ impl ChainSpec {
             Domain::VoluntaryExit => self.domain_voluntary_exit,
             Domain::SelectionProof => self.domain_selection_proof,
             Domain::AggregateAndProof => self.domain_aggregate_and_proof,
+            Domain::BeaconBuilder => self.domain_beacon_builder,
+            Domain::PTCAttester => self.domain_ptc_attester,
             Domain::SyncCommittee => self.domain_sync_committee,
             Domain::ContributionAndProof => self.domain_contribution_and_proof,
             Domain::SyncCommitteeSelectionProof => self.domain_sync_committee_selection_proof,
@@ -924,6 +933,7 @@ impl ChainSpec {
             bls_withdrawal_prefix_byte: 0x00,
             eth1_address_withdrawal_prefix_byte: 0x01,
             compounding_withdrawal_prefix_byte: 0x02,
+            builder_withdrawal_prefix_byte: 0x03,
 
             /*
              * Time parameters
@@ -957,6 +967,8 @@ impl ChainSpec {
             domain_voluntary_exit: 4,
             domain_selection_proof: 5,
             domain_aggregate_and_proof: 6,
+            domain_beacon_builder: 0x1B,
+            domain_ptc_attester: 0x0C,
 
             /*
              * Fork choice
@@ -1078,6 +1090,8 @@ impl ChainSpec {
              */
             gloas_fork_version: [0x07, 0x00, 0x00, 0x00],
             gloas_fork_epoch: None,
+            builder_payment_threshold_numerator: 6,
+            builder_payment_threshold_denominator: 10,
 
             /*
              * Network specific
@@ -1271,6 +1285,7 @@ impl ChainSpec {
             bls_withdrawal_prefix_byte: 0x00,
             eth1_address_withdrawal_prefix_byte: 0x01,
             compounding_withdrawal_prefix_byte: 0x02,
+            builder_withdrawal_prefix_byte: 0x03,
 
             /*
              * Time parameters
@@ -1304,6 +1319,8 @@ impl ChainSpec {
             domain_voluntary_exit: 4,
             domain_selection_proof: 5,
             domain_aggregate_and_proof: 6,
+            domain_beacon_builder: 0x1B,
+            domain_ptc_attester: 0x0C,
 
             /*
              * Fork choice
@@ -1425,6 +1442,8 @@ impl ChainSpec {
              */
             gloas_fork_version: [0x07, 0x00, 0x00, 0x64],
             gloas_fork_epoch: None,
+            builder_payment_threshold_numerator: 6,
+            builder_payment_threshold_denominator: 10,
 
             /*
              * Network specific
@@ -1694,6 +1713,12 @@ pub struct Config {
     #[serde(serialize_with = "serialize_fork_epoch")]
     #[serde(deserialize_with = "deserialize_fork_epoch")]
     pub gloas_fork_epoch: Option<MaybeQuoted<Epoch>>,
+    #[serde(default = "default_builder_payment_threshold_numerator")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub builder_payment_threshold_numerator: u64,
+    #[serde(default = "default_builder_payment_threshold_denominator")]
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub builder_payment_threshold_denominator: u64,
 
     #[serde(with = "serde_utils::quoted_u64")]
     seconds_per_slot: u64,
@@ -1860,6 +1885,14 @@ fn default_gloas_fork_version() -> [u8; 4] {
     [0xff, 0xff, 0xff, 0xff]
 }
 
+fn default_builder_payment_threshold_numerator() -> u64 {
+    6
+}
+
+fn default_builder_payment_threshold_denominator() -> u64 {
+    10
+}
+
 /// Placeholder value: 2^256-2^10 (115792089237316195423570985008687907853269984665640564039457584007913129638912).
 ///
 /// Taken from https://github.com/ethereum/consensus-specs/blob/d5e4828aecafaf1c57ef67a5f23c4ae7b08c5137/configs/mainnet.yaml#L15-L16
@@ -2172,6 +2205,9 @@ impl Config {
                 .gloas_fork_epoch
                 .map(|epoch| MaybeQuoted { value: epoch }),
 
+            builder_payment_threshold_numerator: spec.builder_payment_threshold_numerator,
+            builder_payment_threshold_denominator: spec.builder_payment_threshold_denominator,
+
             seconds_per_slot: spec.seconds_per_slot,
             seconds_per_eth1_block: spec.seconds_per_eth1_block,
             min_validator_withdrawability_delay: spec.min_validator_withdrawability_delay,
@@ -2264,6 +2300,8 @@ impl Config {
             fulu_fork_version,
             gloas_fork_version,
             gloas_fork_epoch,
+            builder_payment_threshold_numerator,
+            builder_payment_threshold_denominator,
             seconds_per_slot,
             seconds_per_eth1_block,
             min_validator_withdrawability_delay,
@@ -2338,6 +2376,8 @@ impl Config {
             fulu_fork_version,
             gloas_fork_version,
             gloas_fork_epoch: gloas_fork_epoch.map(|q| q.value),
+            builder_payment_threshold_numerator,
+            builder_payment_threshold_denominator,
             seconds_per_slot,
             seconds_per_eth1_block,
             min_validator_withdrawability_delay,
@@ -2466,6 +2506,8 @@ mod tests {
             &spec,
         );
         test_domain(Domain::SyncCommittee, spec.domain_sync_committee, &spec);
+        test_domain(Domain::BeaconBuilder, spec.domain_beacon_builder, &spec);
+        test_domain(Domain::PTCAttester, spec.domain_ptc_attester, &spec);
 
         // The builder domain index is zero
         let builder_domain_pre_mask = [0; 4];
diff --git a/consensus/types/src/dumb_macros.rs b/consensus/types/src/dumb_macros.rs
new file mode 100644
index 00000000000..4eae416bb56
--- /dev/null
+++ b/consensus/types/src/dumb_macros.rs
@@ -0,0 +1,108 @@
+// These would usually be created by superstuct but now there's no longer a 1:1 mapping between
+// the variants for ExecutionPayload and the variants for
+// - ExecutionPayloadHeader
+// - FullPayload
+// - BlindedPayload
+// TODO(EIP-7732): get rid of this whole file and panics once the engine_api is refactored for ePBS
+
+#[macro_export]
+macro_rules! map_execution_payload_into_full_payload {
+    ($value:expr, $f:expr) => {
+        match $value {
+            ExecutionPayload::Bellatrix(inner) => {
+                let f: fn(ExecutionPayloadBellatrix<_>, fn(_) -> _) -> _ = $f;
+                f(inner, FullPayload::Bellatrix)
+            }
+            ExecutionPayload::Capella(inner) => {
+                let f: fn(ExecutionPayloadCapella<_>, fn(_) -> _) -> _ = $f;
+                f(inner, FullPayload::Capella)
+            }
+            ExecutionPayload::Deneb(inner) => {
+                let f: fn(ExecutionPayloadDeneb<_>, fn(_) -> _) -> _ = $f;
+                f(inner, FullPayload::Deneb)
+            }
+            ExecutionPayload::Electra(inner) => {
+                let f: fn(ExecutionPayloadElectra<_>, fn(_) -> _) -> _ = $f;
+                f(inner, FullPayload::Electra)
+            }
+            ExecutionPayload::Fulu(inner) => {
+                let f: fn(ExecutionPayloadFulu<_>, fn(_) -> _) -> _ = $f;
+                f(inner, FullPayload::Fulu)
+            }
+            ExecutionPayload::Gloas(_) => panic!("FullPayload::Gloas does not exist!"),
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! map_execution_payload_into_blinded_payload {
+    ($value:expr, $f:expr) => {
+        match $value {
+            ExecutionPayload::Bellatrix(inner) => {
+                let f: fn(ExecutionPayloadBellatrix<_>, fn(_) -> _) -> _ = $f;
+                f(inner, BlindedPayload::Bellatrix)
+            }
+            ExecutionPayload::Capella(inner) => {
+                let f: fn(ExecutionPayloadCapella<_>, fn(_) -> _) -> _ = $f;
+                f(inner, BlindedPayload::Capella)
+            }
+            ExecutionPayload::Deneb(inner) => {
+                let f: fn(ExecutionPayloadDeneb<_>, fn(_) -> _) -> _ = $f;
+                f(inner, BlindedPayload::Deneb)
+            }
+            ExecutionPayload::Electra(inner) => {
+                let f: fn(ExecutionPayloadElectra<_>, fn(_) -> _) -> _ = $f;
+                f(inner, BlindedPayload::Electra)
+            }
+            ExecutionPayload::Fulu(inner) => {
+                let f: fn(ExecutionPayloadFulu<_>, fn(_) -> _) -> _ = $f;
+                f(inner, BlindedPayload::Fulu)
+            }
+            ExecutionPayload::Gloas(_) => panic!("BlindedPayload::Gloas does not exist!"),
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! map_execution_payload_ref_into_execution_payload_header {
+    (&$lifetime:tt _, $value:expr, $f:expr) => {
+        match $value {
+            ExecutionPayloadRef::Bellatrix(inner) => {
+                let f: fn(
+                    &$lifetime ExecutionPayloadBellatrix<_>,
+                    fn(_) -> _,
+                ) -> _ = $f;
+                f(inner, ExecutionPayloadHeader::Bellatrix)
+            }
+            ExecutionPayloadRef::Capella(inner) => {
+                let f: fn(
+                    &$lifetime ExecutionPayloadCapella<_>,
+                    fn(_) -> _,
+                ) -> _ = $f;
+                f(inner, ExecutionPayloadHeader::Capella)
+            }
+            ExecutionPayloadRef::Deneb(inner) => {
+                let f: fn(
+                    &$lifetime ExecutionPayloadDeneb<_>,
+                    fn(_) -> _,
+                ) -> _ = $f;
+                f(inner, ExecutionPayloadHeader::Deneb)
+            }
+            ExecutionPayloadRef::Electra(inner) => {
+                let f: fn(
+                    &$lifetime ExecutionPayloadElectra<_>,
+                    fn(_) -> _,
+                ) -> _ = $f;
+                f(inner, ExecutionPayloadHeader::Electra)
+            }
+            ExecutionPayloadRef::Fulu(inner) => {
+                let f: fn(
+                    &$lifetime ExecutionPayloadFulu<_>,
+                    fn(_) -> _,
+                ) -> _ = $f;
+                f(inner, ExecutionPayloadHeader::Fulu)
+            }
+            ExecutionPayloadRef::Gloas(_) => panic!("ExecutionPayloadHeader::Gloas does not exist!"),
+        }
+    }
+}
diff --git a/consensus/types/src/eth_spec.rs b/consensus/types/src/eth_spec.rs
index 40006caf1ef..22e9a9769bd 100644
--- a/consensus/types/src/eth_spec.rs
+++ b/consensus/types/src/eth_spec.rs
@@ -163,6 +163,14 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq +
     type MaxWithdrawalRequestsPerPayload: Unsigned + Clone + Sync + Send + Debug + PartialEq;
     type MaxPendingDepositsPerEpoch: Unsigned + Clone + Sync + Send + Debug + PartialEq;
 
+    /*
+     * New in Gloas
+     */
+    type PTCSize: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type MaxPayloadAttestations: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type BuilderPendingPaymentsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+    type BuilderPendingWithdrawalsLimit: Unsigned + Clone + Sync + Send + Debug + PartialEq;
+
     fn default_spec() -> ChainSpec;
 
     fn spec_name() -> EthSpecId;
@@ -344,6 +352,11 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq +
         Self::PendingConsolidationsLimit::to_usize()
     }
 
+    /// Returns the `BUILDER_PENDING_WITHDRAWALS_LIMIT` constant for this specification.
+    fn builder_pending_withdrawals_limit() -> usize {
+        Self::BuilderPendingWithdrawalsLimit::to_usize()
+    }
+
     /// Returns the `MAX_CONSOLIDATION_REQUESTS_PER_PAYLOAD` constant for this specification.
     fn max_consolidation_requests_per_payload() -> usize {
         Self::MaxConsolidationRequestsPerPayload::to_usize()
@@ -381,6 +394,16 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq +
     fn proposer_lookahead_slots() -> usize {
         Self::ProposerLookaheadSlots::to_usize()
     }
+
+    /// Returns the `PTCSize` constant for this specification.
+    fn ptc_size() -> usize {
+        Self::PTCSize::to_usize()
+    }
+
+    /// Returns the `MaxPayloadAttestations` constant for this specification.
+    fn max_payload_attestations() -> usize {
+        Self::MaxPayloadAttestations::to_usize()
+    }
 }
 
 /// Macro to inherit some type values from another EthSpec.
@@ -410,6 +433,8 @@ impl EthSpec for MainnetEthSpec {
     type EpochsPerSlashingsVector = U8192;
     type HistoricalRootsLimit = U16777216;
     type ValidatorRegistryLimit = U1099511627776;
+    type BuilderPendingPaymentsLimit = U64; // 2 * SLOTS_PER_EPOCH = 2 * 32 = 64
+    type BuilderPendingWithdrawalsLimit = U1048576;
     type MaxProposerSlashings = U16;
     type MaxAttesterSlashings = U2;
     type MaxAttestations = U128;
@@ -448,6 +473,8 @@ impl EthSpec for MainnetEthSpec {
     type MaxAttestationsElectra = U8;
     type MaxWithdrawalRequestsPerPayload = U16;
     type MaxPendingDepositsPerEpoch = U16;
+    type PTCSize = U512;
+    type MaxPayloadAttestations = U4;
 
     fn default_spec() -> ChainSpec {
         ChainSpec::mainnet()
@@ -488,6 +515,7 @@ impl EthSpec for MinimalEthSpec {
     type BytesPerCell = U2048;
     type KzgCommitmentsInclusionProofDepth = U4;
     type ProposerLookaheadSlots = U16; // Derived from (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH
+    type BuilderPendingPaymentsLimit = U16; // 2 * SLOTS_PER_EPOCH = 2 * 8 = 16
 
     params_from_eth_spec!(MainnetEthSpec {
         JustificationBitsLength,
@@ -497,6 +525,7 @@ impl EthSpec for MinimalEthSpec {
         GenesisEpoch,
         HistoricalRootsLimit,
         ValidatorRegistryLimit,
+        BuilderPendingWithdrawalsLimit,
         MaxProposerSlashings,
         MaxAttesterSlashings,
         MaxAttestations,
@@ -516,7 +545,9 @@ impl EthSpec for MinimalEthSpec {
         MaxAttesterSlashingsElectra,
         MaxAttestationsElectra,
         MaxDepositRequestsPerPayload,
-        MaxWithdrawalRequestsPerPayload
+        MaxWithdrawalRequestsPerPayload,
+        PTCSize,
+        MaxPayloadAttestations
     });
 
     fn default_spec() -> ChainSpec {
@@ -547,6 +578,8 @@ impl EthSpec for GnosisEthSpec {
     type EpochsPerSlashingsVector = U8192;
     type HistoricalRootsLimit = U16777216;
     type ValidatorRegistryLimit = U1099511627776;
+    type BuilderPendingPaymentsLimit = U32; // 2 * SLOTS_PER_EPOCH = 2 * 16 = 32
+    type BuilderPendingWithdrawalsLimit = U1048576;
     type MaxProposerSlashings = U16;
     type MaxAttesterSlashings = U2;
     type MaxAttestations = U128;
@@ -585,6 +618,8 @@ impl EthSpec for GnosisEthSpec {
     type BytesPerCell = U2048;
     type KzgCommitmentsInclusionProofDepth = U4;
     type ProposerLookaheadSlots = U32; // Derived from (MIN_SEED_LOOKAHEAD + 1) * SLOTS_PER_EPOCH
+    type PTCSize = U512;
+    type MaxPayloadAttestations = U2;
 
     fn default_spec() -> ChainSpec {
         ChainSpec::gnosis()
diff --git a/consensus/types/src/execution_bid.rs b/consensus/types/src/execution_bid.rs
new file mode 100644
index 00000000000..a3672daeacc
--- /dev/null
+++ b/consensus/types/src/execution_bid.rs
@@ -0,0 +1,39 @@
+use crate::{test_utils::TestRandom, *};
+use derivative::Derivative;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    Default, Debug, Clone, Serialize, Encode, Decode, Deserialize, TreeHash, Derivative, TestRandom,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derivative(PartialEq, Hash)]
+#[context_deserialize(ForkName)]
+// This is what Potuz' spec calls an `ExecutionPayloadHeader` even though it's clearly a bid.
+// https://github.com/ethereum/consensus-specs/blob/bba2c7be148d6d921d2ca5e1cc528f5daaf456d9/specs/gloas/beacon-chain.md#executionpayloadheader
+pub struct ExecutionBid {
+    pub parent_block_hash: ExecutionBlockHash,
+    pub parent_block_root: Hash256,
+    pub block_hash: ExecutionBlockHash,
+    #[serde(with = "serde_utils::address_hex")]
+    pub fee_recipient: Address,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub gas_limit: u64,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub builder_index: u64,
+    pub slot: Slot,
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub value: u64,
+    pub blob_kzg_commitments_root: Hash256,
+}
+
+impl SignedRoot for ExecutionBid {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(ExecutionBid);
+}
diff --git a/consensus/types/src/execution_payload.rs b/consensus/types/src/execution_payload.rs
index 0de521a484f..80cb57dd24e 100644
--- a/consensus/types/src/execution_payload.rs
+++ b/consensus/types/src/execution_payload.rs
@@ -39,9 +39,7 @@ pub type Withdrawals<E> = VariableList<Withdrawal, <E as EthSpec>::MaxWithdrawal
         ),
     ),
     cast_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
-    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
-    map_into(FullPayload, BlindedPayload),
-    map_ref_into(ExecutionPayloadHeader)
+    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant")
 )]
 #[cfg_attr(
     feature = "arbitrary",
@@ -130,6 +128,7 @@ impl<E: EthSpec> ForkVersionDecode for ExecutionPayload<E> {
 impl<E: EthSpec> ExecutionPayload<E> {
     #[allow(clippy::arithmetic_side_effects)]
     /// Returns the maximum size of an execution payload.
+    /// TODO(EIP-7732): this seems to only exist for the Bellatrix fork, but Mark's branch has it for all the forks, i.e. max_execution_payload_eip7732_size
     pub fn max_execution_payload_bellatrix_size() -> usize {
         // Fixed part
         ExecutionPayloadBellatrix::<E>::default().as_ssz_bytes().len()
diff --git a/consensus/types/src/execution_payload_envelope.rs b/consensus/types/src/execution_payload_envelope.rs
new file mode 100644
index 00000000000..50a7ac97299
--- /dev/null
+++ b/consensus/types/src/execution_payload_envelope.rs
@@ -0,0 +1,103 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use beacon_block_body::KzgCommitments;
+use derivative::Derivative;
+use serde::de::{Deserializer, Error as _};
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use superstruct::superstruct;
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+// in all likelihood, this will be superstructed so might as well start early eh?
+#[superstruct(
+    variants(Gloas, NextFork),
+    variant_attributes(
+        derive(
+            Debug,
+            Clone,
+            Serialize,
+            Deserialize,
+            Encode,
+            Decode,
+            TreeHash,
+            TestRandom,
+            Derivative
+        ),
+        cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary)),
+        derivative(PartialEq, Hash(bound = "E: EthSpec")),
+        serde(bound = "E: EthSpec", deny_unknown_fields),
+        cfg_attr(feature = "arbitrary", arbitrary(bound = "E: EthSpec"))
+    ),
+    ref_attributes(
+        derive(Debug, PartialEq, TreeHash),
+        tree_hash(enum_behaviour = "transparent")
+    ),
+    cast_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
+    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant")
+)]
+#[derive(Debug, Clone, Serialize, Encode, Deserialize, TreeHash, Derivative)]
+#[derivative(PartialEq, Hash(bound = "E: EthSpec"))]
+#[serde(bound = "E: EthSpec", untagged)]
+#[ssz(enum_behaviour = "transparent")]
+#[tree_hash(enum_behaviour = "transparent")]
+pub struct ExecutionPayloadEnvelope<E: EthSpec> {
+    #[superstruct(only(Gloas), partial_getter(rename = "payload_gloas"))]
+    pub payload: ExecutionPayloadGloas<E>,
+    #[superstruct(only(NextFork), partial_getter(rename = "payload_next_fork"))]
+    pub payload: ExecutionPayloadGloas<E>,
+    pub execution_requests: ExecutionRequests<E>,
+    #[serde(with = "serde_utils::quoted_u64")]
+    #[superstruct(getter(copy))]
+    pub builder_index: u64,
+    #[superstruct(getter(copy))]
+    pub beacon_block_root: Hash256,
+    #[superstruct(getter(copy))]
+    pub slot: Slot,
+    pub blob_kzg_commitments: KzgCommitments<E>,
+    #[superstruct(getter(copy))]
+    pub state_root: Hash256,
+}
+
+impl<'a, E: EthSpec> SignedRoot for ExecutionPayloadEnvelopeRef<'a, E> {}
+
+impl<'a, E: EthSpec> ExecutionPayloadEnvelopeRef<'a, E> {
+    pub fn payload(&self) -> ExecutionPayloadRef<'a, E> {
+        match self {
+            Self::Gloas(envelope) => ExecutionPayloadRef::Gloas(&envelope.payload),
+            Self::NextFork(envelope) => ExecutionPayloadRef::Gloas(&envelope.payload),
+        }
+    }
+}
+
+impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadEnvelope<E> {
+    fn context_deserialize<D>(deserializer: D, context: ForkName) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value: Self = serde::Deserialize::deserialize(deserializer)?;
+
+        match (context, &value) {
+            (ForkName::Gloas, Self::Gloas { .. }) => Ok(value),
+            _ => Err(D::Error::custom(format!(
+                "ExecutionPayloadEnvelope does not support fork {context:?}"
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MainnetEthSpec;
+
+    mod gloas {
+        use super::*;
+        ssz_and_tree_hash_tests!(ExecutionPayloadEnvelopeGloas<MainnetEthSpec>);
+    }
+
+    mod next_fork {
+        use super::*;
+        ssz_and_tree_hash_tests!(ExecutionPayloadEnvelopeNextFork<MainnetEthSpec>);
+    }
+}
diff --git a/consensus/types/src/execution_payload_header.rs b/consensus/types/src/execution_payload_header.rs
index 8a18fea1ce5..c72183ef57d 100644
--- a/consensus/types/src/execution_payload_header.rs
+++ b/consensus/types/src/execution_payload_header.rs
@@ -8,7 +8,7 @@ use tree_hash::TreeHash;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Bellatrix, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Default,
@@ -84,12 +84,12 @@ pub struct ExecutionPayloadHeader<E: EthSpec> {
     pub block_hash: ExecutionBlockHash,
     #[superstruct(getter(copy))]
     pub transactions_root: Hash256,
-    #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas), partial_getter(copy))]
+    #[superstruct(only(Capella, Deneb, Electra, Fulu), partial_getter(copy))]
     pub withdrawals_root: Hash256,
-    #[superstruct(only(Deneb, Electra, Fulu, Gloas), partial_getter(copy))]
+    #[superstruct(only(Deneb, Electra, Fulu), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
     pub blob_gas_used: u64,
-    #[superstruct(only(Deneb, Electra, Fulu, Gloas), partial_getter(copy))]
+    #[superstruct(only(Deneb, Electra, Fulu), partial_getter(copy))]
     #[serde(with = "serde_utils::quoted_u64")]
     pub excess_blob_gas: u64,
 }
@@ -115,14 +115,19 @@ impl<E: EthSpec> ExecutionPayloadHeader<E> {
                 ExecutionPayloadHeaderElectra::from_ssz_bytes(bytes).map(Self::Electra)
             }
             ForkName::Fulu => ExecutionPayloadHeaderFulu::from_ssz_bytes(bytes).map(Self::Fulu),
-            ForkName::Gloas => ExecutionPayloadHeaderGloas::from_ssz_bytes(bytes).map(Self::Gloas),
+            ForkName::Gloas => Err(ssz::DecodeError::BytesInvalid(format!(
+                "unsupported fork for ExecutionPayloadHeader: {fork_name}",
+            ))),
         }
     }
 
     #[allow(clippy::arithmetic_side_effects)]
     pub fn ssz_max_var_len_for_fork(fork_name: ForkName) -> usize {
         // TODO(newfork): Add a new case here if there are new variable fields
-        if fork_name.bellatrix_enabled() {
+        if fork_name.gloas_enabled() {
+            // TODO(EIP7732): check this
+            return 0;
+        } else if fork_name.bellatrix_enabled() {
             // Max size of variable length `extra_data` field
             E::max_extra_data_bytes() * <u8 as Encode>::ssz_fixed_len()
         } else {
@@ -137,7 +142,6 @@ impl<E: EthSpec> ExecutionPayloadHeader<E> {
             ExecutionPayloadHeader::Deneb(_) => ForkName::Deneb,
             ExecutionPayloadHeader::Electra(_) => ForkName::Electra,
             ExecutionPayloadHeader::Fulu(_) => ForkName::Fulu,
-            ExecutionPayloadHeader::Gloas(_) => ForkName::Gloas,
         }
     }
 }
@@ -245,30 +249,6 @@ impl<E: EthSpec> ExecutionPayloadHeaderElectra<E> {
     }
 }
 
-impl<E: EthSpec> ExecutionPayloadHeaderFulu<E> {
-    pub fn upgrade_to_gloas(&self) -> ExecutionPayloadHeaderGloas<E> {
-        ExecutionPayloadHeaderGloas {
-            parent_hash: self.parent_hash,
-            fee_recipient: self.fee_recipient,
-            state_root: self.state_root,
-            receipts_root: self.receipts_root,
-            logs_bloom: self.logs_bloom.clone(),
-            prev_randao: self.prev_randao,
-            block_number: self.block_number,
-            gas_limit: self.gas_limit,
-            gas_used: self.gas_used,
-            timestamp: self.timestamp,
-            extra_data: self.extra_data.clone(),
-            base_fee_per_gas: self.base_fee_per_gas,
-            block_hash: self.block_hash,
-            transactions_root: self.transactions_root,
-            withdrawals_root: self.withdrawals_root,
-            blob_gas_used: self.blob_gas_used,
-            excess_blob_gas: self.excess_blob_gas,
-        }
-    }
-}
-
 impl<'a, E: EthSpec> From<&'a ExecutionPayloadBellatrix<E>> for ExecutionPayloadHeaderBellatrix<E> {
     fn from(payload: &'a ExecutionPayloadBellatrix<E>) -> Self {
         Self {
@@ -384,30 +364,6 @@ impl<'a, E: EthSpec> From<&'a ExecutionPayloadFulu<E>> for ExecutionPayloadHeade
     }
 }
 
-impl<'a, E: EthSpec> From<&'a ExecutionPayloadGloas<E>> for ExecutionPayloadHeaderGloas<E> {
-    fn from(payload: &'a ExecutionPayloadGloas<E>) -> Self {
-        Self {
-            parent_hash: payload.parent_hash,
-            fee_recipient: payload.fee_recipient,
-            state_root: payload.state_root,
-            receipts_root: payload.receipts_root,
-            logs_bloom: payload.logs_bloom.clone(),
-            prev_randao: payload.prev_randao,
-            block_number: payload.block_number,
-            gas_limit: payload.gas_limit,
-            gas_used: payload.gas_used,
-            timestamp: payload.timestamp,
-            extra_data: payload.extra_data.clone(),
-            base_fee_per_gas: payload.base_fee_per_gas,
-            block_hash: payload.block_hash,
-            transactions_root: payload.transactions.tree_hash_root(),
-            withdrawals_root: payload.withdrawals.tree_hash_root(),
-            blob_gas_used: payload.blob_gas_used,
-            excess_blob_gas: payload.excess_blob_gas,
-        }
-    }
-}
-
 // These impls are required to work around an inelegance in `to_execution_payload_header`.
 // They only clone headers so they should be relatively cheap.
 impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderBellatrix<E> {
@@ -440,12 +396,6 @@ impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderFulu<E> {
     }
 }
 
-impl<'a, E: EthSpec> From<&'a Self> for ExecutionPayloadHeaderGloas<E> {
-    fn from(payload: &'a Self) -> Self {
-        payload.clone()
-    }
-}
-
 impl<'a, E: EthSpec> From<ExecutionPayloadRef<'a, E>> for ExecutionPayloadHeader<E> {
     fn from(payload: ExecutionPayloadRef<'a, E>) -> Self {
         map_execution_payload_ref_into_execution_payload_header!(
@@ -507,9 +457,6 @@ impl<E: EthSpec> ExecutionPayloadHeaderRefMut<'_, E> {
             ExecutionPayloadHeaderRefMut::Fulu(mut_ref) => {
                 *mut_ref = header.try_into()?;
             }
-            ExecutionPayloadHeaderRefMut::Gloas(mut_ref) => {
-                *mut_ref = header.try_into()?;
-            }
         }
         Ok(())
     }
@@ -537,16 +484,6 @@ impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderFu
     }
 }
 
-impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for ExecutionPayloadHeaderGloas<E> {
-    type Error = BeaconStateError;
-    fn try_from(header: ExecutionPayloadHeader<E>) -> Result<Self, Self::Error> {
-        match header {
-            ExecutionPayloadHeader::Gloas(execution_payload_header) => Ok(execution_payload_header),
-            _ => Err(BeaconStateError::IncorrectStateVariant),
-        }
-    }
-}
-
 impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadHeader<E> {
     fn context_deserialize<D>(deserializer: D, context: ForkName) -> Result<Self, D::Error>
     where
@@ -559,12 +496,6 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadHead
             ))
         };
         Ok(match context {
-            ForkName::Base | ForkName::Altair => {
-                return Err(serde::de::Error::custom(format!(
-                    "ExecutionPayloadHeader failed to deserialize: unsupported fork '{}'",
-                    context
-                )))
-            }
             ForkName::Bellatrix => {
                 Self::Bellatrix(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
@@ -580,8 +511,12 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for ExecutionPayloadHead
             ForkName::Fulu => {
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
-            ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
+
+            ForkName::Base | ForkName::Altair | ForkName::Gloas => {
+                return Err(serde::de::Error::custom(format!(
+                    "ExecutionPayloadHeader failed to deserialize: unsupported fork '{}'",
+                    context
+                )))
             }
         })
     }
diff --git a/consensus/types/src/fork_context.rs b/consensus/types/src/fork_context.rs
index aeb14934f49..d4642104892 100644
--- a/consensus/types/src/fork_context.rs
+++ b/consensus/types/src/fork_context.rs
@@ -180,6 +180,7 @@ mod tests {
         spec.deneb_fork_epoch = Some(Epoch::new(4));
         spec.electra_fork_epoch = Some(Epoch::new(5));
         spec.fulu_fork_epoch = Some(Epoch::new(6));
+        spec.gloas_fork_epoch = Some(Epoch::new(7));
         spec.blob_schedule = BlobSchedule::new(blob_parameters);
         spec
     }
@@ -194,6 +195,7 @@ mod tests {
 
         assert!(context.fork_exists(ForkName::Electra));
         assert!(context.fork_exists(ForkName::Fulu));
+        assert!(context.fork_exists(ForkName::Gloas));
     }
 
     #[test]
diff --git a/consensus/types/src/indexed_payload_attestation.rs b/consensus/types/src/indexed_payload_attestation.rs
new file mode 100644
index 00000000000..ddc2d001854
--- /dev/null
+++ b/consensus/types/src/indexed_payload_attestation.rs
@@ -0,0 +1,32 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use core::slice::Iter;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(TestRandom, TreeHash, Debug, Clone, PartialEq, Encode, Decode, Serialize, Deserialize)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[serde(bound = "E: EthSpec", deny_unknown_fields)]
+#[cfg_attr(feature = "arbitrary", arbitrary(bound = "E: EthSpec"))]
+#[context_deserialize(ForkName)]
+pub struct IndexedPayloadAttestation<E: EthSpec> {
+    #[serde(with = "ssz_types::serde_utils::quoted_u64_var_list")]
+    pub attesting_indices: VariableList<u64, E::PTCSize>,
+    pub data: PayloadAttestationData,
+    pub signature: AggregateSignature,
+}
+
+impl<E: EthSpec> IndexedPayloadAttestation<E> {
+    pub fn attesting_indices_iter(&self) -> Iter<'_, u64> {
+        self.attesting_indices.iter()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(IndexedPayloadAttestation<MainnetEthSpec>);
+}
diff --git a/consensus/types/src/lib.rs b/consensus/types/src/lib.rs
index 86499d6cdb5..f1bd82eb564 100644
--- a/consensus/types/src/lib.rs
+++ b/consensus/types/src/lib.rs
@@ -26,6 +26,8 @@ pub mod beacon_response;
 pub mod beacon_state;
 pub mod bls_to_execution_change;
 pub mod builder_bid;
+pub mod builder_pending_payment;
+pub mod builder_pending_withdrawal;
 pub mod chain_spec;
 pub mod checkpoint;
 pub mod consolidation_request;
@@ -36,11 +38,14 @@ pub mod deposit_data;
 pub mod deposit_message;
 pub mod deposit_request;
 pub mod deposit_tree_snapshot;
+pub mod dumb_macros;
 pub mod enr_fork_id;
 pub mod eth1_data;
 pub mod eth_spec;
+pub mod execution_bid;
 pub mod execution_block_hash;
 pub mod execution_payload;
+pub mod execution_payload_envelope;
 pub mod execution_payload_header;
 pub mod fork;
 pub mod fork_data;
@@ -49,10 +54,15 @@ pub mod graffiti;
 pub mod historical_batch;
 pub mod historical_summary;
 pub mod indexed_attestation;
+pub mod indexed_payload_attestation;
 pub mod light_client_bootstrap;
 pub mod light_client_finality_update;
 pub mod light_client_optimistic_update;
 pub mod light_client_update;
+pub mod payload;
+pub mod payload_attestation;
+pub mod payload_attestation_data;
+pub mod payload_attestation_message;
 pub mod pending_attestation;
 pub mod pending_consolidation;
 pub mod pending_deposit;
@@ -67,6 +77,8 @@ pub mod signed_beacon_block;
 pub mod signed_beacon_block_header;
 pub mod signed_bls_to_execution_change;
 pub mod signed_contribution_and_proof;
+pub mod signed_execution_bid;
+pub mod signed_execution_payload_envelope;
 pub mod signed_voluntary_exit;
 pub mod signing_data;
 pub mod sync_committee_subscription;
@@ -84,7 +96,6 @@ pub mod execution_block_header;
 pub mod execution_requests;
 pub mod fork_context;
 pub mod participation_flags;
-pub mod payload;
 pub mod preset;
 pub mod slot_epoch;
 pub mod subnet_id;
@@ -144,6 +155,8 @@ pub use crate::beacon_response::{
 pub use crate::beacon_state::{Error as BeaconStateError, *};
 pub use crate::blob_sidecar::{BlobIdentifier, BlobSidecar, BlobSidecarList, BlobsList};
 pub use crate::bls_to_execution_change::BlsToExecutionChange;
+pub use crate::builder_pending_payment::BuilderPendingPayment;
+pub use crate::builder_pending_withdrawal::BuilderPendingWithdrawal;
 pub use crate::chain_spec::{ChainSpec, Config, Domain};
 pub use crate::checkpoint::Checkpoint;
 pub use crate::config_and_preset::{
@@ -165,6 +178,7 @@ pub use crate::enr_fork_id::EnrForkId;
 pub use crate::epoch_cache::{EpochCache, EpochCacheError, EpochCacheKey};
 pub use crate::eth1_data::Eth1Data;
 pub use crate::eth_spec::EthSpecId;
+pub use crate::execution_bid::ExecutionBid;
 pub use crate::execution_block_hash::ExecutionBlockHash;
 pub use crate::execution_block_header::{EncodableExecutionBlockHeader, ExecutionBlockHeader};
 pub use crate::execution_payload::{
@@ -172,10 +186,14 @@ pub use crate::execution_payload::{
     ExecutionPayloadElectra, ExecutionPayloadFulu, ExecutionPayloadGloas, ExecutionPayloadRef,
     Transaction, Transactions, Withdrawals,
 };
+pub use crate::execution_payload_envelope::{
+    ExecutionPayloadEnvelope, ExecutionPayloadEnvelopeGloas, ExecutionPayloadEnvelopeNextFork,
+    ExecutionPayloadEnvelopeRef,
+};
 pub use crate::execution_payload_header::{
     ExecutionPayloadHeader, ExecutionPayloadHeaderBellatrix, ExecutionPayloadHeaderCapella,
     ExecutionPayloadHeaderDeneb, ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu,
-    ExecutionPayloadHeaderGloas, ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut,
+    ExecutionPayloadHeaderRef, ExecutionPayloadHeaderRefMut,
 };
 pub use crate::execution_requests::{ExecutionRequests, RequestType};
 pub use crate::fork::Fork;
@@ -187,39 +205,40 @@ pub use crate::historical_batch::HistoricalBatch;
 pub use crate::indexed_attestation::{
     IndexedAttestation, IndexedAttestationBase, IndexedAttestationElectra, IndexedAttestationRef,
 };
+pub use crate::indexed_payload_attestation::IndexedPayloadAttestation;
 pub use crate::light_client_bootstrap::{
     LightClientBootstrap, LightClientBootstrapAltair, LightClientBootstrapCapella,
     LightClientBootstrapDeneb, LightClientBootstrapElectra, LightClientBootstrapFulu,
-    LightClientBootstrapGloas,
 };
 pub use crate::light_client_finality_update::{
     LightClientFinalityUpdate, LightClientFinalityUpdateAltair, LightClientFinalityUpdateCapella,
     LightClientFinalityUpdateDeneb, LightClientFinalityUpdateElectra,
-    LightClientFinalityUpdateFulu, LightClientFinalityUpdateGloas,
+    LightClientFinalityUpdateFulu,
 };
 pub use crate::light_client_header::{
     LightClientHeader, LightClientHeaderAltair, LightClientHeaderCapella, LightClientHeaderDeneb,
-    LightClientHeaderElectra, LightClientHeaderFulu, LightClientHeaderGloas,
+    LightClientHeaderElectra, LightClientHeaderFulu,
 };
 pub use crate::light_client_optimistic_update::{
     LightClientOptimisticUpdate, LightClientOptimisticUpdateAltair,
     LightClientOptimisticUpdateCapella, LightClientOptimisticUpdateDeneb,
     LightClientOptimisticUpdateElectra, LightClientOptimisticUpdateFulu,
-    LightClientOptimisticUpdateGloas,
 };
 pub use crate::light_client_update::{
     Error as LightClientUpdateError, LightClientUpdate, LightClientUpdateAltair,
     LightClientUpdateCapella, LightClientUpdateDeneb, LightClientUpdateElectra,
-    LightClientUpdateFulu, LightClientUpdateGloas, MerkleProof,
+    LightClientUpdateFulu, MerkleProof,
 };
 pub use crate::participation_flags::ParticipationFlags;
 pub use crate::payload::{
     AbstractExecPayload, BlindedPayload, BlindedPayloadBellatrix, BlindedPayloadCapella,
-    BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadGloas,
-    BlindedPayloadRef, BlockType, ExecPayload, FullPayload, FullPayloadBellatrix,
-    FullPayloadCapella, FullPayloadDeneb, FullPayloadElectra, FullPayloadFulu, FullPayloadGloas,
-    FullPayloadRef, OwnedExecPayload,
+    BlindedPayloadDeneb, BlindedPayloadElectra, BlindedPayloadFulu, BlindedPayloadRef, BlockType,
+    ExecPayload, FullPayload, FullPayloadBellatrix, FullPayloadCapella, FullPayloadDeneb,
+    FullPayloadElectra, FullPayloadFulu, FullPayloadRef, OwnedExecPayload,
 };
+pub use crate::payload_attestation::PayloadAttestation;
+pub use crate::payload_attestation_data::PayloadAttestationData;
+pub use crate::payload_attestation_message::PayloadAttestationMessage;
 pub use crate::pending_attestation::PendingAttestation;
 pub use crate::pending_consolidation::PendingConsolidation;
 pub use crate::pending_deposit::PendingDeposit;
@@ -247,6 +266,8 @@ pub use crate::signed_beacon_block::{
 pub use crate::signed_beacon_block_header::SignedBeaconBlockHeader;
 pub use crate::signed_bls_to_execution_change::SignedBlsToExecutionChange;
 pub use crate::signed_contribution_and_proof::SignedContributionAndProof;
+pub use crate::signed_execution_bid::SignedExecutionBid;
+pub use crate::signed_execution_payload_envelope::SignedExecutionPayloadEnvelope;
 pub use crate::signed_voluntary_exit::SignedVoluntaryExit;
 pub use crate::signing_data::{SignedRoot, SigningData};
 pub use crate::slot_epoch::{Epoch, Slot};
diff --git a/consensus/types/src/light_client_bootstrap.rs b/consensus/types/src/light_client_bootstrap.rs
index 356b1ec9835..1326677d04b 100644
--- a/consensus/types/src/light_client_bootstrap.rs
+++ b/consensus/types/src/light_client_bootstrap.rs
@@ -3,7 +3,7 @@ use crate::{
     light_client_update::*, test_utils::TestRandom, BeaconState, ChainSpec, ContextDeserialize,
     EthSpec, FixedVector, ForkName, Hash256, LightClientHeader, LightClientHeaderAltair,
     LightClientHeaderCapella, LightClientHeaderDeneb, LightClientHeaderElectra,
-    LightClientHeaderFulu, LightClientHeaderGloas, SignedBlindedBeaconBlock, Slot, SyncCommittee,
+    LightClientHeaderFulu, SignedBlindedBeaconBlock, Slot, SyncCommittee,
 };
 use derivative::Derivative;
 use serde::{Deserialize, Deserializer, Serialize};
@@ -17,7 +17,7 @@ use tree_hash_derive::TreeHash;
 /// A LightClientBootstrap is the initializer we send over to light_client nodes
 /// that are trying to generate their basic storage when booting up.
 #[superstruct(
-    variants(Altair, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Altair, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -62,8 +62,6 @@ pub struct LightClientBootstrap<E: EthSpec> {
     pub header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "header_fulu"))]
     pub header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "header_gloas"))]
-    pub header: LightClientHeaderGloas<E>,
     /// The `SyncCommittee` used in the requested period.
     pub current_sync_committee: Arc<SyncCommittee<E>>,
     /// Merkle proof for sync committee
@@ -73,7 +71,7 @@ pub struct LightClientBootstrap<E: EthSpec> {
     )]
     pub current_sync_committee_branch: FixedVector<Hash256, CurrentSyncCommitteeProofLen>,
     #[superstruct(
-        only(Electra, Fulu, Gloas),
+        only(Electra, Fulu),
         partial_getter(rename = "current_sync_committee_branch_electra")
     )]
     pub current_sync_committee_branch: FixedVector<Hash256, CurrentSyncCommitteeProofLenElectra>,
@@ -90,7 +88,6 @@ impl<E: EthSpec> LightClientBootstrap<E> {
             Self::Deneb(_) => func(ForkName::Deneb),
             Self::Electra(_) => func(ForkName::Electra),
             Self::Fulu(_) => func(ForkName::Fulu),
-            Self::Gloas(_) => func(ForkName::Gloas),
         }
     }
 
@@ -110,7 +107,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
             ForkName::Deneb => Self::Deneb(LightClientBootstrapDeneb::from_ssz_bytes(bytes)?),
             ForkName::Electra => Self::Electra(LightClientBootstrapElectra::from_ssz_bytes(bytes)?),
             ForkName::Fulu => Self::Fulu(LightClientBootstrapFulu::from_ssz_bytes(bytes)?),
-            ForkName::Gloas => Self::Gloas(LightClientBootstrapGloas::from_ssz_bytes(bytes)?),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "LightClientBootstrap decoding for {fork_name} not implemented"
@@ -132,7 +129,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
             ForkName::Deneb => <LightClientBootstrapDeneb<E> as Encode>::ssz_fixed_len(),
             ForkName::Electra => <LightClientBootstrapElectra<E> as Encode>::ssz_fixed_len(),
             ForkName::Fulu => <LightClientBootstrapFulu<E> as Encode>::ssz_fixed_len(),
-            ForkName::Gloas => <LightClientBootstrapGloas<E> as Encode>::ssz_fixed_len(),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
         fixed_len + LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
     }
@@ -173,11 +170,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
                 current_sync_committee,
                 current_sync_committee_branch: current_sync_committee_branch.into(),
             }),
-            ForkName::Gloas => Self::Gloas(LightClientBootstrapGloas {
-                header: LightClientHeaderGloas::block_to_light_client_header(block)?,
-                current_sync_committee,
-                current_sync_committee_branch: current_sync_committee_branch.into(),
-            }),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
 
         Ok(light_client_bootstrap)
@@ -223,11 +216,7 @@ impl<E: EthSpec> LightClientBootstrap<E> {
                 current_sync_committee,
                 current_sync_committee_branch: current_sync_committee_branch.into(),
             }),
-            ForkName::Gloas => Self::Gloas(LightClientBootstrapGloas {
-                header: LightClientHeaderGloas::block_to_light_client_header(block)?,
-                current_sync_committee,
-                current_sync_committee_branch: current_sync_committee_branch.into(),
-            }),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
 
         Ok(light_client_bootstrap)
@@ -268,7 +257,11 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientBootstrap
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
             ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
+                // TODO(EIP-7732): check if this is correct
+                return Err(serde::de::Error::custom(format!(
+                    "LightClientBootstrap failed to deserialize: unsupported fork '{}'",
+                    context
+                )));
             }
         })
     }
@@ -306,10 +299,4 @@ mod tests {
         use crate::{LightClientBootstrapFulu, MainnetEthSpec};
         ssz_tests!(LightClientBootstrapFulu<MainnetEthSpec>);
     }
-
-    #[cfg(test)]
-    mod gloas {
-        use crate::{LightClientBootstrapGloas, MainnetEthSpec};
-        ssz_tests!(LightClientBootstrapGloas<MainnetEthSpec>);
-    }
 }
diff --git a/consensus/types/src/light_client_finality_update.rs b/consensus/types/src/light_client_finality_update.rs
index e91965870d1..addbb6a4cf6 100644
--- a/consensus/types/src/light_client_finality_update.rs
+++ b/consensus/types/src/light_client_finality_update.rs
@@ -4,8 +4,7 @@ use crate::ChainSpec;
 use crate::{
     light_client_update::*, test_utils::TestRandom, ContextDeserialize, ForkName,
     LightClientHeaderAltair, LightClientHeaderCapella, LightClientHeaderDeneb,
-    LightClientHeaderElectra, LightClientHeaderFulu, LightClientHeaderGloas,
-    SignedBlindedBeaconBlock,
+    LightClientHeaderElectra, LightClientHeaderFulu, SignedBlindedBeaconBlock,
 };
 use derivative::Derivative;
 use serde::{Deserialize, Deserializer, Serialize};
@@ -17,7 +16,7 @@ use test_random_derive::TestRandom;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Altair, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Altair, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -62,8 +61,6 @@ pub struct LightClientFinalityUpdate<E: EthSpec> {
     pub attested_header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "attested_header_fulu"))]
     pub attested_header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "attested_header_gloas"))]
-    pub attested_header: LightClientHeaderGloas<E>,
     /// The last `BeaconBlockHeader` from the last attested finalized block (end of epoch).
     #[superstruct(only(Altair), partial_getter(rename = "finalized_header_altair"))]
     pub finalized_header: LightClientHeaderAltair<E>,
@@ -75,8 +72,6 @@ pub struct LightClientFinalityUpdate<E: EthSpec> {
     pub finalized_header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "finalized_header_fulu"))]
     pub finalized_header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "finalized_header_gloas"))]
-    pub finalized_header: LightClientHeaderGloas<E>,
     /// Merkle proof attesting finalized header.
     #[superstruct(
         only(Altair, Capella, Deneb),
@@ -84,7 +79,7 @@ pub struct LightClientFinalityUpdate<E: EthSpec> {
     )]
     pub finality_branch: FixedVector<Hash256, FinalizedRootProofLen>,
     #[superstruct(
-        only(Electra, Fulu, Gloas),
+        only(Electra, Fulu),
         partial_getter(rename = "finality_branch_electra")
     )]
     pub finality_branch: FixedVector<Hash256, FinalizedRootProofLenElectra>,
@@ -165,18 +160,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
                 sync_aggregate,
                 signature_slot,
             }),
-            ForkName::Gloas => Self::Gloas(LightClientFinalityUpdateGloas {
-                attested_header: LightClientHeaderGloas::block_to_light_client_header(
-                    attested_block,
-                )?,
-                finalized_header: LightClientHeaderGloas::block_to_light_client_header(
-                    finalized_block,
-                )?,
-                finality_branch: finality_branch.into(),
-                sync_aggregate,
-                signature_slot,
-            }),
-
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => return Err(Error::AltairForkNotActive),
         };
 
@@ -193,7 +177,6 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
             Self::Deneb(_) => func(ForkName::Deneb),
             Self::Electra(_) => func(ForkName::Electra),
             Self::Fulu(_) => func(ForkName::Fulu),
-            Self::Gloas(_) => func(ForkName::Gloas),
         }
     }
 
@@ -231,7 +214,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
                 Self::Electra(LightClientFinalityUpdateElectra::from_ssz_bytes(bytes)?)
             }
             ForkName::Fulu => Self::Fulu(LightClientFinalityUpdateFulu::from_ssz_bytes(bytes)?),
-            ForkName::Gloas => Self::Gloas(LightClientFinalityUpdateGloas::from_ssz_bytes(bytes)?),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "LightClientFinalityUpdate decoding for {fork_name} not implemented"
@@ -253,7 +236,7 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
             ForkName::Deneb => <LightClientFinalityUpdateDeneb<E> as Encode>::ssz_fixed_len(),
             ForkName::Electra => <LightClientFinalityUpdateElectra<E> as Encode>::ssz_fixed_len(),
             ForkName::Fulu => <LightClientFinalityUpdateFulu<E> as Encode>::ssz_fixed_len(),
-            ForkName::Gloas => <LightClientFinalityUpdateGloas<E> as Encode>::ssz_fixed_len(),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
         // `2 *` because there are two headers in the update
         fixed_size + 2 * LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
@@ -307,7 +290,11 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientFinalityU
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
             ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
+                // TODO(EIP-7732): check if this is correct
+                return Err(serde::de::Error::custom(format!(
+                    "LightClientBootstrap failed to deserialize: unsupported fork '{}'",
+                    context
+                )));
             }
         })
     }
@@ -345,10 +332,4 @@ mod tests {
         use crate::{LightClientFinalityUpdateFulu, MainnetEthSpec};
         ssz_tests!(LightClientFinalityUpdateFulu<MainnetEthSpec>);
     }
-
-    #[cfg(test)]
-    mod gloas {
-        use crate::{LightClientFinalityUpdateGloas, MainnetEthSpec};
-        ssz_tests!(LightClientFinalityUpdateGloas<MainnetEthSpec>);
-    }
 }
diff --git a/consensus/types/src/light_client_header.rs b/consensus/types/src/light_client_header.rs
index 07f42b84137..7417f509902 100644
--- a/consensus/types/src/light_client_header.rs
+++ b/consensus/types/src/light_client_header.rs
@@ -3,8 +3,8 @@ use crate::ChainSpec;
 use crate::{light_client_update::*, BeaconBlockBody};
 use crate::{
     test_utils::TestRandom, EthSpec, ExecutionPayloadHeaderCapella, ExecutionPayloadHeaderDeneb,
-    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, ExecutionPayloadHeaderGloas,
-    FixedVector, Hash256, SignedBlindedBeaconBlock,
+    ExecutionPayloadHeaderElectra, ExecutionPayloadHeaderFulu, FixedVector, Hash256,
+    SignedBlindedBeaconBlock,
 };
 use crate::{BeaconBlockHeader, ExecutionPayloadHeader};
 use crate::{ContextDeserialize, ForkName};
@@ -18,7 +18,7 @@ use test_random_derive::TestRandom;
 use tree_hash_derive::TreeHash;
 
 #[superstruct(
-    variants(Altair, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Altair, Capella, Deneb, Electra, Fulu,),
     variant_attributes(
         derive(
             Debug,
@@ -68,10 +68,8 @@ pub struct LightClientHeader<E: EthSpec> {
     pub execution: ExecutionPayloadHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_header_fulu"))]
     pub execution: ExecutionPayloadHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_header_gloas"))]
-    pub execution: ExecutionPayloadHeaderGloas<E>,
 
-    #[superstruct(only(Capella, Deneb, Electra, Fulu, Gloas))]
+    #[superstruct(only(Capella, Deneb, Electra, Fulu))]
     pub execution_branch: FixedVector<Hash256, ExecutionPayloadProofLen>,
 
     #[ssz(skip_serializing, skip_deserializing)]
@@ -106,9 +104,7 @@ impl<E: EthSpec> LightClientHeader<E> {
             ForkName::Fulu => {
                 LightClientHeader::Fulu(LightClientHeaderFulu::block_to_light_client_header(block)?)
             }
-            ForkName::Gloas => LightClientHeader::Gloas(
-                LightClientHeaderGloas::block_to_light_client_header(block)?,
-            ),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
         Ok(header)
     }
@@ -130,9 +126,7 @@ impl<E: EthSpec> LightClientHeader<E> {
             ForkName::Fulu => {
                 LightClientHeader::Fulu(LightClientHeaderFulu::from_ssz_bytes(bytes)?)
             }
-            ForkName::Gloas => {
-                LightClientHeader::Gloas(LightClientHeaderGloas::from_ssz_bytes(bytes)?)
-            }
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "LightClientHeader decoding for {fork_name} not implemented"
@@ -152,7 +146,10 @@ impl<E: EthSpec> LightClientHeader<E> {
     }
 
     pub fn ssz_max_var_len_for_fork(fork_name: ForkName) -> usize {
-        if fork_name.capella_enabled() {
+        if fork_name.gloas_enabled() {
+            // TODO(EIP7732): check this
+            return 0;
+        } else if fork_name.capella_enabled() {
             ExecutionPayloadHeader::<E>::ssz_max_var_len_for_fork(fork_name)
         } else {
             0
@@ -348,48 +345,6 @@ impl<E: EthSpec> Default for LightClientHeaderFulu<E> {
     }
 }
 
-impl<E: EthSpec> LightClientHeaderGloas<E> {
-    pub fn block_to_light_client_header(
-        block: &SignedBlindedBeaconBlock<E>,
-    ) -> Result<Self, Error> {
-        let payload = block
-            .message()
-            .execution_payload()?
-            .execution_payload_gloas()?;
-
-        let header = ExecutionPayloadHeaderGloas::from(payload);
-        let beacon_block_body = BeaconBlockBody::from(
-            block
-                .message()
-                .body_gloas()
-                .map_err(|_| Error::BeaconBlockBodyError)?
-                .to_owned(),
-        );
-
-        let execution_branch = beacon_block_body
-            .to_ref()
-            .block_body_merkle_proof(EXECUTION_PAYLOAD_INDEX)?;
-
-        Ok(LightClientHeaderGloas {
-            beacon: block.message().block_header(),
-            execution: header,
-            execution_branch: FixedVector::new(execution_branch)?,
-            _phantom_data: PhantomData,
-        })
-    }
-}
-
-impl<E: EthSpec> Default for LightClientHeaderGloas<E> {
-    fn default() -> Self {
-        Self {
-            beacon: BeaconBlockHeader::empty(),
-            execution: ExecutionPayloadHeaderGloas::default(),
-            execution_branch: FixedVector::default(),
-            _phantom_data: PhantomData,
-        }
-    }
-}
-
 impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientHeader<E> {
     fn context_deserialize<D>(deserializer: D, context: ForkName) -> Result<Self, D::Error>
     where
@@ -423,9 +378,7 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientHeader<E>
             ForkName::Fulu => {
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
-            ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
-            }
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         })
     }
 }
@@ -462,10 +415,4 @@ mod tests {
         use crate::{LightClientHeaderFulu, MainnetEthSpec};
         ssz_tests!(LightClientHeaderFulu<MainnetEthSpec>);
     }
-
-    #[cfg(test)]
-    mod gloas {
-        use crate::{LightClientHeaderGloas, MainnetEthSpec};
-        ssz_tests!(LightClientHeaderGloas<MainnetEthSpec>);
-    }
 }
diff --git a/consensus/types/src/light_client_optimistic_update.rs b/consensus/types/src/light_client_optimistic_update.rs
index 4b8c080ca58..6e0d59cbcac 100644
--- a/consensus/types/src/light_client_optimistic_update.rs
+++ b/consensus/types/src/light_client_optimistic_update.rs
@@ -4,7 +4,7 @@ use crate::test_utils::TestRandom;
 use crate::{
     light_client_update::*, ChainSpec, LightClientHeaderAltair, LightClientHeaderCapella,
     LightClientHeaderDeneb, LightClientHeaderElectra, LightClientHeaderFulu,
-    LightClientHeaderGloas, SignedBlindedBeaconBlock,
+    SignedBlindedBeaconBlock,
 };
 use derivative::Derivative;
 use serde::{Deserialize, Deserializer, Serialize};
@@ -19,7 +19,7 @@ use tree_hash_derive::TreeHash;
 /// A LightClientOptimisticUpdate is the update we send on each slot,
 /// it is based off the current unfinalized epoch is verified only against BLS signature.
 #[superstruct(
-    variants(Altair, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Altair, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -64,8 +64,6 @@ pub struct LightClientOptimisticUpdate<E: EthSpec> {
     pub attested_header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "attested_header_fulu"))]
     pub attested_header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "attested_header_gloas"))]
-    pub attested_header: LightClientHeaderGloas<E>,
     /// current sync aggregate
     pub sync_aggregate: SyncAggregate<E>,
     /// Slot of the sync aggregated signature
@@ -121,13 +119,7 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
                 sync_aggregate,
                 signature_slot,
             }),
-            ForkName::Gloas => Self::Gloas(LightClientOptimisticUpdateGloas {
-                attested_header: LightClientHeaderGloas::block_to_light_client_header(
-                    attested_block,
-                )?,
-                sync_aggregate,
-                signature_slot,
-            }),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => return Err(Error::AltairForkNotActive),
         };
 
@@ -144,7 +136,6 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
             Self::Deneb(_) => func(ForkName::Deneb),
             Self::Electra(_) => func(ForkName::Electra),
             Self::Fulu(_) => func(ForkName::Fulu),
-            Self::Gloas(_) => func(ForkName::Gloas),
         }
     }
 
@@ -184,9 +175,7 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
                 Self::Electra(LightClientOptimisticUpdateElectra::from_ssz_bytes(bytes)?)
             }
             ForkName::Fulu => Self::Fulu(LightClientOptimisticUpdateFulu::from_ssz_bytes(bytes)?),
-            ForkName::Gloas => {
-                Self::Gloas(LightClientOptimisticUpdateGloas::from_ssz_bytes(bytes)?)
-            }
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
             ForkName::Base => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "LightClientOptimisticUpdate decoding for {fork_name} not implemented"
@@ -208,7 +197,7 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
             ForkName::Deneb => <LightClientOptimisticUpdateDeneb<E> as Encode>::ssz_fixed_len(),
             ForkName::Electra => <LightClientOptimisticUpdateElectra<E> as Encode>::ssz_fixed_len(),
             ForkName::Fulu => <LightClientOptimisticUpdateFulu<E> as Encode>::ssz_fixed_len(),
-            ForkName::Gloas => <LightClientOptimisticUpdateGloas<E> as Encode>::ssz_fixed_len(),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
         fixed_len + LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
     }
@@ -261,7 +250,11 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientOptimisti
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
             ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
+                // TODO(EIP-7732): check if this is correct
+                return Err(serde::de::Error::custom(format!(
+                    "LightClientBootstrap failed to deserialize: unsupported fork '{}'",
+                    context
+                )));
             }
         })
     }
@@ -299,10 +292,4 @@ mod tests {
         use crate::{LightClientOptimisticUpdateFulu, MainnetEthSpec};
         ssz_tests!(LightClientOptimisticUpdateFulu<MainnetEthSpec>);
     }
-
-    #[cfg(test)]
-    mod gloas {
-        use crate::{LightClientOptimisticUpdateGloas, MainnetEthSpec};
-        ssz_tests!(LightClientOptimisticUpdateGloas<MainnetEthSpec>);
-    }
 }
diff --git a/consensus/types/src/light_client_update.rs b/consensus/types/src/light_client_update.rs
index d05f5152d11..8ee0897af8d 100644
--- a/consensus/types/src/light_client_update.rs
+++ b/consensus/types/src/light_client_update.rs
@@ -5,7 +5,7 @@ use crate::LightClientHeader;
 use crate::{
     beacon_state, test_utils::TestRandom, ChainSpec, ContextDeserialize, Epoch, ForkName,
     LightClientHeaderAltair, LightClientHeaderCapella, LightClientHeaderDeneb,
-    LightClientHeaderFulu, LightClientHeaderGloas, SignedBlindedBeaconBlock,
+    LightClientHeaderFulu, SignedBlindedBeaconBlock,
 };
 use derivative::Derivative;
 use safe_arith::ArithError;
@@ -100,7 +100,7 @@ impl From<milhouse::Error> for Error {
 /// or to sync up to the last committee period, we need to have one ready for each ALTAIR period
 /// we go over, note: there is no need to keep all of the updates from [ALTAIR_PERIOD, CURRENT_PERIOD].
 #[superstruct(
-    variants(Altair, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Altair, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -145,8 +145,6 @@ pub struct LightClientUpdate<E: EthSpec> {
     pub attested_header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "attested_header_fulu"))]
     pub attested_header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "attested_header_gloas"))]
-    pub attested_header: LightClientHeaderGloas<E>,
     /// The `SyncCommittee` used in the next period.
     pub next_sync_committee: Arc<SyncCommittee<E>>,
     // Merkle proof for next sync committee
@@ -156,7 +154,7 @@ pub struct LightClientUpdate<E: EthSpec> {
     )]
     pub next_sync_committee_branch: NextSyncCommitteeBranch,
     #[superstruct(
-        only(Electra, Fulu, Gloas),
+        only(Electra, Fulu),
         partial_getter(rename = "next_sync_committee_branch_electra")
     )]
     pub next_sync_committee_branch: NextSyncCommitteeBranchElectra,
@@ -171,8 +169,6 @@ pub struct LightClientUpdate<E: EthSpec> {
     pub finalized_header: LightClientHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "finalized_header_fulu"))]
     pub finalized_header: LightClientHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "finalized_header_gloas"))]
-    pub finalized_header: LightClientHeaderGloas<E>,
     /// Merkle proof attesting finalized header.
     #[superstruct(
         only(Altair, Capella, Deneb),
@@ -180,7 +176,7 @@ pub struct LightClientUpdate<E: EthSpec> {
     )]
     pub finality_branch: FinalityBranch,
     #[superstruct(
-        only(Electra, Fulu, Gloas),
+        only(Electra, Fulu),
         partial_getter(rename = "finality_branch_electra")
     )]
     pub finality_branch: FinalityBranchElectra,
@@ -220,9 +216,7 @@ impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for LightClientUpdate<E>
             ForkName::Fulu => {
                 Self::Fulu(Deserialize::deserialize(deserializer).map_err(convert_err)?)
             }
-            ForkName::Gloas => {
-                Self::Gloas(Deserialize::deserialize(deserializer).map_err(convert_err)?)
-            }
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         })
     }
 }
@@ -364,32 +358,10 @@ impl<E: EthSpec> LightClientUpdate<E> {
                     signature_slot: block_slot,
                 })
             }
-            fork_name @ ForkName::Gloas => {
-                let attested_header =
-                    LightClientHeaderGloas::block_to_light_client_header(attested_block)?;
-
-                let finalized_header = if let Some(finalized_block) = finalized_block {
-                    if finalized_block.fork_name_unchecked() == fork_name {
-                        LightClientHeaderGloas::block_to_light_client_header(finalized_block)?
-                    } else {
-                        LightClientHeaderGloas::default()
-                    }
-                } else {
-                    LightClientHeaderGloas::default()
-                };
-
-                Self::Gloas(LightClientUpdateGloas {
-                    attested_header,
-                    next_sync_committee,
-                    next_sync_committee_branch: next_sync_committee_branch.into(),
-                    finalized_header,
-                    finality_branch: finality_branch.into(),
-                    sync_aggregate: sync_aggregate.clone(),
-                    signature_slot: block_slot,
-                })
-            } // To add a new fork, just append the new fork variant on the latest fork. Forks that
-              // have a distinct execution header will need a new LightClientUpdate variant only
-              // if you need to test or support lightclient usages
+            // To add a new fork, just append the new fork variant on the latest fork. Forks that
+            // have a distinct execution header will need a new LightClientUpdate variant only
+            // if you need to test or support lightclient usages
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
 
         Ok(light_client_update)
@@ -404,7 +376,8 @@ impl<E: EthSpec> LightClientUpdate<E> {
             ForkName::Deneb => Self::Deneb(LightClientUpdateDeneb::from_ssz_bytes(bytes)?),
             ForkName::Electra => Self::Electra(LightClientUpdateElectra::from_ssz_bytes(bytes)?),
             ForkName::Fulu => Self::Fulu(LightClientUpdateFulu::from_ssz_bytes(bytes)?),
-            ForkName::Gloas => Self::Gloas(LightClientUpdateGloas::from_ssz_bytes(bytes)?),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
+
             ForkName::Base => {
                 return Err(ssz::DecodeError::BytesInvalid(format!(
                     "LightClientUpdate decoding for {fork_name} not implemented"
@@ -422,7 +395,6 @@ impl<E: EthSpec> LightClientUpdate<E> {
             LightClientUpdate::Deneb(update) => update.attested_header.beacon.slot,
             LightClientUpdate::Electra(update) => update.attested_header.beacon.slot,
             LightClientUpdate::Fulu(update) => update.attested_header.beacon.slot,
-            LightClientUpdate::Gloas(update) => update.attested_header.beacon.slot,
         }
     }
 
@@ -433,7 +405,6 @@ impl<E: EthSpec> LightClientUpdate<E> {
             LightClientUpdate::Deneb(update) => update.finalized_header.beacon.slot,
             LightClientUpdate::Electra(update) => update.finalized_header.beacon.slot,
             LightClientUpdate::Fulu(update) => update.finalized_header.beacon.slot,
-            LightClientUpdate::Gloas(update) => update.finalized_header.beacon.slot,
         }
     }
 
@@ -554,7 +525,7 @@ impl<E: EthSpec> LightClientUpdate<E> {
             ForkName::Deneb => <LightClientUpdateDeneb<E> as Encode>::ssz_fixed_len(),
             ForkName::Electra => <LightClientUpdateElectra<E> as Encode>::ssz_fixed_len(),
             ForkName::Fulu => <LightClientUpdateFulu<E> as Encode>::ssz_fixed_len(),
-            ForkName::Gloas => <LightClientUpdateGloas<E> as Encode>::ssz_fixed_len(),
+            ForkName::Gloas => todo!("Gloas light client not implemented"),
         };
         fixed_len + 2 * LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
     }
@@ -569,7 +540,6 @@ impl<E: EthSpec> LightClientUpdate<E> {
             Self::Deneb(_) => func(ForkName::Deneb),
             Self::Electra(_) => func(ForkName::Electra),
             Self::Fulu(_) => func(ForkName::Fulu),
-            Self::Gloas(_) => func(ForkName::Gloas),
         }
     }
 }
@@ -632,13 +602,6 @@ mod tests {
         ssz_tests!(LightClientUpdateFulu<MainnetEthSpec>);
     }
 
-    #[cfg(test)]
-    mod gloas {
-        use super::*;
-        use crate::MainnetEthSpec;
-        ssz_tests!(LightClientUpdateGloas<MainnetEthSpec>);
-    }
-
     #[test]
     fn finalized_root_params() {
         assert!(2usize.pow(FINALIZED_ROOT_PROOF_LEN as u32) <= FINALIZED_ROOT_INDEX);
diff --git a/consensus/types/src/payload.rs b/consensus/types/src/payload.rs
index 1ee8496d62a..2bafeccfe64 100644
--- a/consensus/types/src/payload.rs
+++ b/consensus/types/src/payload.rs
@@ -105,7 +105,6 @@ pub trait AbstractExecPayload<E: EthSpec>:
     + TryInto<Self::Deneb>
     + TryInto<Self::Electra>
     + TryInto<Self::Fulu>
-    + TryInto<Self::Gloas>
     + Sync
 {
     type Ref<'a>: ExecPayload<E>
@@ -114,8 +113,7 @@ pub trait AbstractExecPayload<E: EthSpec>:
         + From<&'a Self::Capella>
         + From<&'a Self::Deneb>
         + From<&'a Self::Electra>
-        + From<&'a Self::Fulu>
-        + From<&'a Self::Gloas>;
+        + From<&'a Self::Fulu>;
 
     type Bellatrix: OwnedExecPayload<E>
         + Into<Self>
@@ -142,15 +140,10 @@ pub trait AbstractExecPayload<E: EthSpec>:
         + for<'a> From<Cow<'a, ExecutionPayloadFulu<E>>>
         + TryFrom<ExecutionPayloadHeaderFulu<E>>
         + Sync;
-    type Gloas: OwnedExecPayload<E>
-        + Into<Self>
-        + for<'a> From<Cow<'a, ExecutionPayloadGloas<E>>>
-        + TryFrom<ExecutionPayloadHeaderGloas<E>>
-        + Sync;
 }
 
 #[superstruct(
-    variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Bellatrix, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -205,8 +198,6 @@ pub struct FullPayload<E: EthSpec> {
     pub execution_payload: ExecutionPayloadElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))]
     pub execution_payload: ExecutionPayloadFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))]
-    pub execution_payload: ExecutionPayloadGloas<E>,
 }
 
 impl<E: EthSpec> From<FullPayload<E>> for ExecutionPayload<E> {
@@ -326,9 +317,6 @@ impl<E: EthSpec> ExecPayload<E> for FullPayload<E> {
             FullPayload::Fulu(ref inner) => {
                 Ok(inner.execution_payload.withdrawals.tree_hash_root())
             }
-            FullPayload::Gloas(ref inner) => {
-                Ok(inner.execution_payload.withdrawals.tree_hash_root())
-            }
         }
     }
 
@@ -340,7 +328,6 @@ impl<E: EthSpec> ExecPayload<E> for FullPayload<E> {
             FullPayload::Deneb(ref inner) => Ok(inner.execution_payload.blob_gas_used),
             FullPayload::Electra(ref inner) => Ok(inner.execution_payload.blob_gas_used),
             FullPayload::Fulu(ref inner) => Ok(inner.execution_payload.blob_gas_used),
-            FullPayload::Gloas(ref inner) => Ok(inner.execution_payload.blob_gas_used),
         }
     }
 
@@ -372,7 +359,7 @@ impl<E: EthSpec> FullPayload<E> {
             ForkName::Deneb => Ok(FullPayloadDeneb::default().into()),
             ForkName::Electra => Ok(FullPayloadElectra::default().into()),
             ForkName::Fulu => Ok(FullPayloadFulu::default().into()),
-            ForkName::Gloas => Ok(FullPayloadGloas::default().into()),
+            ForkName::Gloas => Err(Error::IncorrectStateVariant),
         }
     }
 }
@@ -473,9 +460,6 @@ impl<E: EthSpec> ExecPayload<E> for FullPayloadRef<'_, E> {
                 Ok(inner.execution_payload.withdrawals.tree_hash_root())
             }
             FullPayloadRef::Fulu(inner) => Ok(inner.execution_payload.withdrawals.tree_hash_root()),
-            FullPayloadRef::Gloas(inner) => {
-                Ok(inner.execution_payload.withdrawals.tree_hash_root())
-            }
         }
     }
 
@@ -487,7 +471,6 @@ impl<E: EthSpec> ExecPayload<E> for FullPayloadRef<'_, E> {
             FullPayloadRef::Deneb(inner) => Ok(inner.execution_payload.blob_gas_used),
             FullPayloadRef::Electra(inner) => Ok(inner.execution_payload.blob_gas_used),
             FullPayloadRef::Fulu(inner) => Ok(inner.execution_payload.blob_gas_used),
-            FullPayloadRef::Gloas(inner) => Ok(inner.execution_payload.blob_gas_used),
         }
     }
 
@@ -511,7 +494,6 @@ impl<E: EthSpec> AbstractExecPayload<E> for FullPayload<E> {
     type Deneb = FullPayloadDeneb<E>;
     type Electra = FullPayloadElectra<E>;
     type Fulu = FullPayloadFulu<E>;
-    type Gloas = FullPayloadGloas<E>;
 }
 
 impl<E: EthSpec> From<ExecutionPayload<E>> for FullPayload<E> {
@@ -530,7 +512,7 @@ impl<E: EthSpec> TryFrom<ExecutionPayloadHeader<E>> for FullPayload<E> {
 }
 
 #[superstruct(
-    variants(Bellatrix, Capella, Deneb, Electra, Fulu, Gloas),
+    variants(Bellatrix, Capella, Deneb, Electra, Fulu),
     variant_attributes(
         derive(
             Debug,
@@ -584,8 +566,6 @@ pub struct BlindedPayload<E: EthSpec> {
     pub execution_payload_header: ExecutionPayloadHeaderElectra<E>,
     #[superstruct(only(Fulu), partial_getter(rename = "execution_payload_fulu"))]
     pub execution_payload_header: ExecutionPayloadHeaderFulu<E>,
-    #[superstruct(only(Gloas), partial_getter(rename = "execution_payload_gloas"))]
-    pub execution_payload_header: ExecutionPayloadHeaderGloas<E>,
 }
 
 impl<'a, E: EthSpec> From<BlindedPayloadRef<'a, E>> for BlindedPayload<E> {
@@ -679,7 +659,6 @@ impl<E: EthSpec> ExecPayload<E> for BlindedPayload<E> {
                 Ok(inner.execution_payload_header.withdrawals_root)
             }
             BlindedPayload::Fulu(ref inner) => Ok(inner.execution_payload_header.withdrawals_root),
-            BlindedPayload::Gloas(ref inner) => Ok(inner.execution_payload_header.withdrawals_root),
         }
     }
 
@@ -691,7 +670,6 @@ impl<E: EthSpec> ExecPayload<E> for BlindedPayload<E> {
             BlindedPayload::Deneb(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
             BlindedPayload::Electra(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
             BlindedPayload::Fulu(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
-            BlindedPayload::Gloas(ref inner) => Ok(inner.execution_payload_header.blob_gas_used),
         }
     }
 
@@ -791,7 +769,6 @@ impl<'b, E: EthSpec> ExecPayload<E> for BlindedPayloadRef<'b, E> {
                 Ok(inner.execution_payload_header.withdrawals_root)
             }
             BlindedPayloadRef::Fulu(inner) => Ok(inner.execution_payload_header.withdrawals_root),
-            BlindedPayloadRef::Gloas(inner) => Ok(inner.execution_payload_header.withdrawals_root),
         }
     }
 
@@ -803,7 +780,6 @@ impl<'b, E: EthSpec> ExecPayload<E> for BlindedPayloadRef<'b, E> {
             BlindedPayloadRef::Deneb(inner) => Ok(inner.execution_payload_header.blob_gas_used),
             BlindedPayloadRef::Electra(inner) => Ok(inner.execution_payload_header.blob_gas_used),
             BlindedPayloadRef::Fulu(inner) => Ok(inner.execution_payload_header.blob_gas_used),
-            BlindedPayloadRef::Gloas(inner) => Ok(inner.execution_payload_header.blob_gas_used),
         }
     }
 
@@ -1114,13 +1090,6 @@ impl_exec_payload_for_fork!(
     ExecutionPayloadFulu,
     Fulu
 );
-impl_exec_payload_for_fork!(
-    BlindedPayloadGloas,
-    FullPayloadGloas,
-    ExecutionPayloadHeaderGloas,
-    ExecutionPayloadGloas,
-    Gloas
-);
 
 impl<E: EthSpec> AbstractExecPayload<E> for BlindedPayload<E> {
     type Ref<'a> = BlindedPayloadRef<'a, E>;
@@ -1129,7 +1098,6 @@ impl<E: EthSpec> AbstractExecPayload<E> for BlindedPayload<E> {
     type Deneb = BlindedPayloadDeneb<E>;
     type Electra = BlindedPayloadElectra<E>;
     type Fulu = BlindedPayloadFulu<E>;
-    type Gloas = BlindedPayloadGloas<E>;
 }
 
 impl<E: EthSpec> From<ExecutionPayload<E>> for BlindedPayload<E> {
@@ -1171,11 +1139,6 @@ impl<E: EthSpec> From<ExecutionPayloadHeader<E>> for BlindedPayload<E> {
                     execution_payload_header,
                 })
             }
-            ExecutionPayloadHeader::Gloas(execution_payload_header) => {
-                Self::Gloas(BlindedPayloadGloas {
-                    execution_payload_header,
-                })
-            }
         }
     }
 }
@@ -1198,9 +1161,6 @@ impl<E: EthSpec> From<BlindedPayload<E>> for ExecutionPayloadHeader<E> {
             BlindedPayload::Fulu(blinded_payload) => {
                 ExecutionPayloadHeader::Fulu(blinded_payload.execution_payload_header)
             }
-            BlindedPayload::Gloas(blinded_payload) => {
-                ExecutionPayloadHeader::Gloas(blinded_payload.execution_payload_header)
-            }
         }
     }
 }
diff --git a/consensus/types/src/payload_attestation.rs b/consensus/types/src/payload_attestation.rs
new file mode 100644
index 00000000000..48b0a3e3b3e
--- /dev/null
+++ b/consensus/types/src/payload_attestation.rs
@@ -0,0 +1,28 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use derivative::Derivative;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    TestRandom, TreeHash, Debug, Clone, Encode, Decode, Serialize, Deserialize, Derivative,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[serde(bound = "E: EthSpec", deny_unknown_fields)]
+#[cfg_attr(feature = "arbitrary", arbitrary(bound = "E: EthSpec"))]
+#[derivative(PartialEq, Hash)]
+#[context_deserialize(ForkName)]
+pub struct PayloadAttestation<E: EthSpec> {
+    pub aggregation_bits: BitList<E::PTCSize>,
+    pub data: PayloadAttestationData,
+    pub signature: AggregateSignature,
+}
+
+#[cfg(test)]
+mod payload_attestation_tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PayloadAttestation<MinimalEthSpec>);
+}
diff --git a/consensus/types/src/payload_attestation_data.rs b/consensus/types/src/payload_attestation_data.rs
new file mode 100644
index 00000000000..01e9a1e8f8e
--- /dev/null
+++ b/consensus/types/src/payload_attestation_data.rs
@@ -0,0 +1,27 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    TestRandom, TreeHash, Debug, Clone, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, Hash,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[context_deserialize(ForkName)]
+pub struct PayloadAttestationData {
+    pub beacon_block_root: Hash256,
+    pub slot: Slot,
+    pub payload_present: bool,
+    pub blob_data_available: bool,
+}
+
+impl SignedRoot for PayloadAttestationData {}
+
+#[cfg(test)]
+mod payload_attestation_data_tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PayloadAttestationData);
+}
diff --git a/consensus/types/src/payload_attestation_message.rs b/consensus/types/src/payload_attestation_message.rs
new file mode 100644
index 00000000000..46179e1deac
--- /dev/null
+++ b/consensus/types/src/payload_attestation_message.rs
@@ -0,0 +1,23 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(TestRandom, TreeHash, Debug, Clone, PartialEq, Encode, Decode, Serialize, Deserialize)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[context_deserialize(ForkName)]
+pub struct PayloadAttestationMessage {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub validator_index: u64,
+    pub data: PayloadAttestationData,
+    pub signature: AggregateSignature,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(PayloadAttestationMessage);
+}
diff --git a/consensus/types/src/signed_beacon_block.rs b/consensus/types/src/signed_beacon_block.rs
index aa41b6113d9..ee892efe483 100644
--- a/consensus/types/src/signed_beacon_block.rs
+++ b/consensus/types/src/signed_beacon_block.rs
@@ -648,59 +648,15 @@ impl<E: EthSpec> SignedBeaconBlockFulu<E, BlindedPayload<E>> {
     }
 }
 
-impl<E: EthSpec> SignedBeaconBlockGloas<E, BlindedPayload<E>> {
-    pub fn into_full_block(
-        self,
-        execution_payload: ExecutionPayloadGloas<E>,
-    ) -> SignedBeaconBlockGloas<E, FullPayload<E>> {
-        let SignedBeaconBlockGloas {
-            message:
-                BeaconBlockGloas {
-                    slot,
-                    proposer_index,
-                    parent_root,
-                    state_root,
-                    body:
-                        BeaconBlockBodyGloas {
-                            randao_reveal,
-                            eth1_data,
-                            graffiti,
-                            proposer_slashings,
-                            attester_slashings,
-                            attestations,
-                            deposits,
-                            voluntary_exits,
-                            sync_aggregate,
-                            execution_payload: BlindedPayloadGloas { .. },
-                            bls_to_execution_changes,
-                            blob_kzg_commitments,
-                            execution_requests,
-                        },
-                },
-            signature,
-        } = self;
+// We can convert gloas blocks without payloads into blocks "with" payloads.
+// TODO(EIP-7732) Look into whether we can remove this in the future since no blinded blocks post-gloas
+impl<E: EthSpec> From<SignedBeaconBlockGloas<E, BlindedPayload<E>>>
+    for SignedBeaconBlockGloas<E, FullPayload<E>>
+{
+    fn from(signed_block: SignedBeaconBlockGloas<E, BlindedPayload<E>>) -> Self {
+        let SignedBeaconBlockGloas { message, signature } = signed_block;
         SignedBeaconBlockGloas {
-            message: BeaconBlockGloas {
-                slot,
-                proposer_index,
-                parent_root,
-                state_root,
-                body: BeaconBlockBodyGloas {
-                    randao_reveal,
-                    eth1_data,
-                    graffiti,
-                    proposer_slashings,
-                    attester_slashings,
-                    attestations,
-                    deposits,
-                    voluntary_exits,
-                    sync_aggregate,
-                    execution_payload: FullPayloadGloas { execution_payload },
-                    bls_to_execution_changes,
-                    blob_kzg_commitments,
-                    execution_requests,
-                },
-            },
+            message: message.into(),
             signature,
         }
     }
@@ -729,9 +685,7 @@ impl<E: EthSpec> SignedBeaconBlock<E, BlindedPayload<E>> {
             (SignedBeaconBlock::Fulu(block), Some(ExecutionPayload::Fulu(payload))) => {
                 SignedBeaconBlock::Fulu(block.into_full_block(payload))
             }
-            (SignedBeaconBlock::Gloas(block), Some(ExecutionPayload::Gloas(payload))) => {
-                SignedBeaconBlock::Gloas(block.into_full_block(payload))
-            }
+            (SignedBeaconBlock::Gloas(block), _) => SignedBeaconBlock::Gloas(block.into()),
             // avoid wildcard matching forks so that compiler will
             // direct us here when a new fork has been added
             (SignedBeaconBlock::Bellatrix(_), _) => return None,
@@ -739,7 +693,7 @@ impl<E: EthSpec> SignedBeaconBlock<E, BlindedPayload<E>> {
             (SignedBeaconBlock::Deneb(_), _) => return None,
             (SignedBeaconBlock::Electra(_), _) => return None,
             (SignedBeaconBlock::Fulu(_), _) => return None,
-            (SignedBeaconBlock::Gloas(_), _) => return None,
+            // TODO(EIP-7732) Determine if need a match arm for gloas here
         };
         Some(full_block)
     }
diff --git a/consensus/types/src/signed_execution_bid.rs b/consensus/types/src/signed_execution_bid.rs
new file mode 100644
index 00000000000..4be520565a6
--- /dev/null
+++ b/consensus/types/src/signed_execution_bid.rs
@@ -0,0 +1,35 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use derivative::Derivative;
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[derive(
+    TestRandom, TreeHash, Debug, Clone, Encode, Decode, Serialize, Deserialize, Derivative,
+)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[derivative(PartialEq, Hash)]
+#[context_deserialize(ForkName)]
+// https://github.com/ethereum/consensus-specs/blob/bba2c7be148d6d921d2ca5e1cc528f5daaf456d9/specs/gloas/beacon-chain.md#signedexecutionpayloadheader
+pub struct SignedExecutionBid {
+    pub message: ExecutionBid,
+    pub signature: Signature,
+}
+
+impl SignedExecutionBid {
+    pub fn empty() -> Self {
+        Self {
+            message: ExecutionBid::default(),
+            signature: Signature::empty(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    ssz_and_tree_hash_tests!(SignedExecutionBid);
+}
diff --git a/consensus/types/src/signed_execution_payload_envelope.rs b/consensus/types/src/signed_execution_payload_envelope.rs
new file mode 100644
index 00000000000..bc2c4e994f0
--- /dev/null
+++ b/consensus/types/src/signed_execution_payload_envelope.rs
@@ -0,0 +1,89 @@
+use crate::test_utils::TestRandom;
+use crate::*;
+use derivative::Derivative;
+use serde::de::{Deserializer, Error as _};
+use serde::{Deserialize, Serialize};
+use ssz_derive::{Decode, Encode};
+use superstruct::superstruct;
+use test_random_derive::TestRandom;
+use tree_hash_derive::TreeHash;
+
+#[superstruct(
+    variants(Gloas, NextFork),
+    variant_attributes(
+        derive(
+            Debug,
+            Clone,
+            Serialize,
+            Deserialize,
+            Encode,
+            Decode,
+            TreeHash,
+            TestRandom,
+            Derivative
+        ),
+        cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary)),
+        derivative(PartialEq, Hash(bound = "E: EthSpec")),
+        serde(bound = "E: EthSpec", deny_unknown_fields),
+        cfg_attr(feature = "arbitrary", arbitrary(bound = "E: EthSpec"))
+    ),
+    ref_attributes(
+        derive(Debug, PartialEq, TreeHash),
+        tree_hash(enum_behaviour = "transparent")
+    ),
+    cast_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant"),
+    partial_getter_error(ty = "Error", expr = "BeaconStateError::IncorrectStateVariant")
+)]
+#[derive(Debug, Clone, Serialize, Encode, Deserialize, TreeHash, Derivative)]
+#[derivative(PartialEq, Hash(bound = "E: EthSpec"))]
+#[serde(bound = "E: EthSpec", untagged)]
+#[ssz(enum_behaviour = "transparent")]
+#[tree_hash(enum_behaviour = "transparent")]
+pub struct SignedExecutionPayloadEnvelope<E: EthSpec> {
+    #[superstruct(only(Gloas), partial_getter(rename = "message_gloas"))]
+    pub message: ExecutionPayloadEnvelopeGloas<E>,
+    #[superstruct(only(NextFork), partial_getter(rename = "message_next_fork"))]
+    pub message: crate::execution_payload_envelope::ExecutionPayloadEnvelopeNextFork<E>,
+    pub signature: Signature,
+}
+
+impl<E: EthSpec> SignedExecutionPayloadEnvelope<E> {
+    pub fn message(&self) -> ExecutionPayloadEnvelopeRef<E> {
+        match self {
+            Self::Gloas(ref signed) => ExecutionPayloadEnvelopeRef::Gloas(&signed.message),
+            Self::NextFork(ref signed) => ExecutionPayloadEnvelopeRef::NextFork(&signed.message),
+        }
+    }
+}
+
+impl<'de, E: EthSpec> ContextDeserialize<'de, ForkName> for SignedExecutionPayloadEnvelope<E> {
+    fn context_deserialize<D>(deserializer: D, context: ForkName) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value: Self = Deserialize::deserialize(deserializer)?;
+
+        match (context, &value) {
+            (ForkName::Gloas, Self::Gloas { .. }) => Ok(value),
+            _ => Err(D::Error::custom(format!(
+                "SignedExecutionPayloadEnvelope does not support fork {context:?}"
+            ))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::MainnetEthSpec;
+
+    mod gloas {
+        use super::*;
+        ssz_and_tree_hash_tests!(SignedExecutionPayloadEnvelopeGloas<MainnetEthSpec>);
+    }
+
+    mod next_fork {
+        use super::*;
+        ssz_and_tree_hash_tests!(SignedExecutionPayloadEnvelopeNextFork<MainnetEthSpec>);
+    }
+}
diff --git a/testing/ef_tests/src/cases/operations.rs b/testing/ef_tests/src/cases/operations.rs
index 80aa9de6f97..f4efeb0c6bf 100644
--- a/testing/ef_tests/src/cases/operations.rs
+++ b/testing/ef_tests/src/cases/operations.rs
@@ -301,6 +301,7 @@ impl<E: EthSpec> Operation<E> for BeaconBlockBody<E, FullPayload<E>> {
                 ForkName::Deneb => BeaconBlockBody::Deneb(<_>::from_ssz_bytes(bytes)?),
                 ForkName::Electra => BeaconBlockBody::Electra(<_>::from_ssz_bytes(bytes)?),
                 ForkName::Fulu => BeaconBlockBody::Fulu(<_>::from_ssz_bytes(bytes)?),
+                // TODO(EIP-7732): See if we need to handle Gloas here
                 _ => panic!(),
             })
         })
@@ -360,6 +361,7 @@ impl<E: EthSpec> Operation<E> for BeaconBlockBody<E, BlindedPayload<E>> {
                     let inner = <BeaconBlockBodyFulu<E, FullPayload<E>>>::from_ssz_bytes(bytes)?;
                     BeaconBlockBody::Fulu(inner.clone_as_blinded())
                 }
+                // TODO(EIP-7732): See if we need to handle Gloas here
                 _ => panic!(),
             })
         })
@@ -411,6 +413,7 @@ impl<E: EthSpec> Operation<E> for WithdrawalsPayload<E> {
         spec: &ChainSpec,
         _: &Operations<E, Self>,
     ) -> Result<(), BlockProcessingError> {
+        // TODO(EIP-7732): implement separate gloas and non-gloas variants of process_withdrawals
         process_withdrawals::<_, FullPayload<_>>(state, self.payload.to_ref(), spec)
     }
 }