feat: add v0.8 and v0.9 support to user operation type lib

Author: dancoombs

bin/rundler/Cargo.toml

@@ -9,6 +9,7 @@ description = """
 ERC-4337 bundler implementation
 """
 publish = false
+default-run = "rundler"
 
 [dependencies]
 alloy-consensus.workspace = true

bin/rundler/src/cli/pool.rs

@@ -205,7 +205,7 @@ impl PoolArgs {
         let pool_config_base = PoolConfig {
             // update per entry point
             entry_point: Address::ZERO,
-            entry_point_version: EntryPointVersion::Unspecified,
+            entry_point_version: EntryPointVersion::V0_6,
             mempool_channel_configs: HashMap::new(),
             // Base config
             chain_spec: chain_spec.clone(),

crates/builder/src/bundle_sender.rs

@@ -852,6 +852,9 @@ where
             .context("builder should remove update entities in the pool")
     }
 
+    // TODO(entrypoints): In entrypoint v0.8+ we can no longer rely on the user operation hash
+    // built from a packed user operation to match the mempool hash, as its lacking its authorization
+    // Either (1) pull the authorization from the reverted transaction or (2) use sender/nonce to remove
     async fn process_revert(&self, tx_hash: B256) -> anyhow::Result<()> {
         warn!("Bundle transaction {tx_hash:?} reverted onchain");
 

crates/builder/src/task.rs

@@ -230,8 +230,9 @@ where
                     bundle_sender_actions.extend(actions);
                     supported_entry_points.insert(self.args.chain_spec.entry_point_address_v0_7);
                 }
-                EntryPointVersion::Unspecified => {
-                    panic!("Unspecified entry point version")
+                EntryPointVersion::V0_8 | EntryPointVersion::V0_9 => {
+                    // TODO(entrypoints)
+                    todo!("entry point v0.8 and v0.9 are not supported");
                 }
             }
         }

crates/contracts/src/v0_7.rs

@@ -158,6 +158,10 @@ sol!(
         ) external view returns (DepositInfo memory info);
 
         function balanceOf(address account) external view returns (uint256);
+
+        function getUserOpHash(
+            PackedUserOperation calldata userOp
+        ) public view returns (bytes32);
     }
 
     #[allow(missing_docs)]
@@ -257,6 +261,28 @@ sol!(
     }
 );
 
+mod no_sig {
+    use alloy_sol_macro::sol;
+
+    sol!(
+        /// Packed user operation without signature
+        /// Used for hashing the user operation to calculate the correct
+        /// EIP-712 type hash according to UserOperationLib.sol
+        #[allow(missing_docs)]
+        #[derive(Default, Debug, PartialEq, Eq)]
+        struct PackedUserOperation {
+            address sender;
+            uint256 nonce;
+            bytes initCode;
+            bytes callData;
+            bytes32 accountGasLimits;
+            uint256 preVerificationGas;
+            bytes32 gasFees;
+            bytes paymasterAndData;
+        }
+    );
+}
+
 sol!(
     #[allow(missing_docs)]
     #[sol(rpc)]
@@ -310,3 +336,20 @@ static __VERIFICATION_GAS_ESTIMATION_HELPER_V0_7_DEPLOYED_BYTECODE: [u8; 5252] =
 
 pub static VERIFICATION_GAS_ESTIMATION_HELPER_V0_7_DEPLOYED_BYTECODE: Bytes =
     Bytes::from_static(&__VERIFICATION_GAS_ESTIMATION_HELPER_V0_7_DEPLOYED_BYTECODE);
+
+pub use no_sig::PackedUserOperation as PackedUserOperationNoSig;
+
+impl From<PackedUserOperation> for PackedUserOperationNoSig {
+    fn from(puo: PackedUserOperation) -> Self {
+        PackedUserOperationNoSig {
+            sender: puo.sender,
+            nonce: puo.nonce,
+            initCode: puo.initCode,
+            callData: puo.callData,
+            accountGasLimits: puo.accountGasLimits,
+            preVerificationGas: puo.preVerificationGas,
+            gasFees: puo.gasFees,
+            paymasterAndData: puo.paymasterAndData,
+        }
+    }
+}

crates/pool/proto/op_pool/op_pool.proto

@@ -24,6 +24,14 @@ message UserOperation {
   }
 }
 
+enum EntryPointVersion {
+  ENTRY_POINT_VERSION_UNSPECIFIED = 0;
+  ENTRY_POINT_VERSION_V0_6 = 1;
+  ENTRY_POINT_VERSION_V0_7 = 2;
+  ENTRY_POINT_VERSION_V0_8 = 3;
+  ENTRY_POINT_VERSION_V0_9 = 4;
+}
+
 message UserOperationPermissions {
   bool trusted = 1;
   optional uint64 max_allowed_in_pool_for_sender = 2;
@@ -125,6 +133,9 @@ message UserOperationV07 {
   AuthorizationTuple authorization_tuple = 18;
   // aggregator
   bytes aggregator = 19;
+
+  // Entry point version
+  EntryPointVersion entry_point_version = 20;
 }
 
 enum EntityType {

crates/pool/src/chain.rs

@@ -883,7 +883,11 @@ impl<P: EvmProvider> Chain<P> {
                 Some(EntryPointVersion::V0_7) => {
                     Self::load_v0_7(log, &mut mined_ops, &mut entity_balance_updates)
                 }
-                Some(EntryPointVersion::Unspecified) | None => {
+                Some(EntryPointVersion::V0_8) | Some(EntryPointVersion::V0_9) => {
+                    // TODO(entrypoints)
+                    todo!("entry point v0.8 and v0.9 are not supported");
+                }
+                None => {
                     warn!(
                         "Log with unknown entry point address: {:?}. Ignoring.",
                         log.address()

crates/pool/src/server/local.rs

@@ -709,8 +709,9 @@ impl LocalPoolServerRunner {
                                                 break 'resp Err(anyhow::anyhow!("Invalid user operation version for mempool v0.7 {:?}", op.uo_type()).into());
                                             }
                                         }
-                                        EntryPointVersion::Unspecified => {
-                                            panic!("Found mempool with unspecified entry point version")
+                                        EntryPointVersion::V0_8 | EntryPointVersion::V0_9 => {
+                                            // TODO(entrypoints)
+                                            todo!("entry point v0.8 and v0.9 are not supported");
                                         }
                                     }
 

crates/pool/src/server/remote/protos.rs

@@ -30,7 +30,8 @@ use rundler_types::{
     },
     v0_6, v0_7, BundlerSponsorship as RundlerBundlerSponsorship, Entity as RundlerEntity,
     EntityInfos, EntityType as RundlerEntityType, EntityUpdate as RundlerEntityUpdate,
-    EntityUpdateType as RundlerEntityUpdateType, StakeInfo as RundlerStakeInfo, UserOperation as _,
+    EntityUpdateType as RundlerEntityUpdateType, EntryPointVersion as RundlerEntryPointVersion,
+    StakeInfo as RundlerStakeInfo, UserOperation as _,
     UserOperationPermissions as RundlerUserOperationPermissions, UserOperationVariant,
     ValidTimeRange,
 };
@@ -173,6 +174,7 @@ impl From<&v0_7::UserOperation> for UserOperation {
                 .aggregator()
                 .map(|a| a.to_proto_bytes())
                 .unwrap_or_default(),
+            entry_point_version: EntryPointVersion::from(op.entry_point_version()).into(),
         };
         UserOperation {
             uo: Some(user_operation::Uo::V07(op)),
@@ -190,8 +192,12 @@ impl TryUoFromProto<UserOperationV07> for v0_7::UserOperation {
             .as_ref()
             .map(|authorization| Eip7702Auth::from(authorization.clone()));
 
+        let ep_version = EntryPointVersion::try_from(op.entry_point_version)
+            .map_err(|_| ConversionError::InvalidEnumValue(op.entry_point_version))?;
+
         let mut builder = v0_7::UserOperationBuilder::new(
             chain_spec,
+            ep_version.try_into()?,
             v0_7::UserOperationRequiredFields {
                 sender: from_bytes(&op.sender)?,
                 nonce: from_bytes(&op.nonce)?,
@@ -718,3 +724,30 @@ impl TryFrom<PoolOperationSummary> for RundlerPoolOperationSummary {
         })
     }
 }
+
+impl From<RundlerEntryPointVersion> for EntryPointVersion {
+    fn from(version: RundlerEntryPointVersion) -> Self {
+        match version {
+            RundlerEntryPointVersion::V0_6 => EntryPointVersion::V06,
+            RundlerEntryPointVersion::V0_7 => EntryPointVersion::V07,
+            RundlerEntryPointVersion::V0_8 => EntryPointVersion::V08,
+            RundlerEntryPointVersion::V0_9 => EntryPointVersion::V09,
+        }
+    }
+}
+
+impl TryFrom<EntryPointVersion> for RundlerEntryPointVersion {
+    type Error = ConversionError;
+
+    fn try_from(version: EntryPointVersion) -> Result<Self, Self::Error> {
+        match version {
+            EntryPointVersion::V06 => Ok(RundlerEntryPointVersion::V0_6),
+            EntryPointVersion::V07 => Ok(RundlerEntryPointVersion::V0_7),
+            EntryPointVersion::V08 => Ok(RundlerEntryPointVersion::V0_8),
+            EntryPointVersion::V09 => Ok(RundlerEntryPointVersion::V0_9),
+            EntryPointVersion::Unspecified => {
+                Err(ConversionError::InvalidEnumValue(version as i32))
+            }
+        }
+    }
+}

crates/pool/src/task.rs

@@ -13,7 +13,7 @@
 
 use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
-use anyhow::{bail, Context};
+use anyhow::Context;
 use futures::FutureExt;
 use rundler_provider::{EntryPoint, Providers, ProvidersWithEntryPointT};
 use rundler_sim::{
@@ -148,8 +148,9 @@ where
 
                     mempools.insert(pool_config.entry_point, pool);
                 }
-                EntryPointVersion::Unspecified => {
-                    bail!("Unsupported entry point version");
+                EntryPointVersion::V0_8 | EntryPointVersion::V0_9 => {
+                    // TODO(entrypoints)
+                    todo!("entry point v0.8 and v0.9 are not supported");
                 }
             }
         }