From d14a732ac66d6068be51fe0248d42c7fb5306481 Mon Sep 17 00:00:00 2001 From: Andrei De Stefani Date: Thu, 11 Dec 2025 14:31:36 +0100 Subject: [PATCH 1/3] feat(audit): add Kafka reader for UserOp events - Add UserOpEventWrapper struct with key, event, timestamp - Add UserOpEventReader trait with read_event() and commit() - Add KafkaUserOpAuditLogReader implementation - Add integration test verifying real Kafka publish/read flow --- crates/audit/src/reader.rs | 101 +++++++++++++++++++++++- crates/audit/tests/integration_tests.rs | 57 ++++++++++++- 2 files changed, 154 insertions(+), 4 deletions(-) diff --git a/crates/audit/src/reader.rs b/crates/audit/src/reader.rs index 207b8ac6..3df399d2 100644 --- a/crates/audit/src/reader.rs +++ b/crates/audit/src/reader.rs @@ -1,4 +1,4 @@ -use crate::types::BundleEvent; +use crate::types::{BundleEvent, UserOpEvent}; use anyhow::Result; use async_trait::async_trait; use rdkafka::{ @@ -130,3 +130,102 @@ impl KafkaAuditLogReader { &self.topic } } + +#[derive(Debug, Clone)] +pub struct UserOpEventWrapper { + pub key: String, + pub event: UserOpEvent, + pub timestamp: i64, +} + +#[async_trait] +pub trait UserOpEventReader { + async fn read_event(&mut self) -> Result; + async fn commit(&mut self) -> Result<()>; +} + +pub struct KafkaUserOpAuditLogReader { + consumer: StreamConsumer, + topic: String, + last_message_offset: Option, + last_message_partition: Option, +} + +impl KafkaUserOpAuditLogReader { + pub fn new(consumer: StreamConsumer, topic: String) -> Result { + consumer.subscribe(&[&topic])?; + Ok(Self { + consumer, + topic, + last_message_offset: None, + last_message_partition: None, + }) + } + + pub fn topic(&self) -> &str { + &self.topic + } +} + +#[async_trait] +impl UserOpEventReader for KafkaUserOpAuditLogReader { + async fn read_event(&mut self) -> Result { + match self.consumer.recv().await { + Ok(message) => { + let payload = message + .payload() + .ok_or_else(|| anyhow::anyhow!("Message has no payload"))?; + + let timestamp = match message.timestamp() { + Timestamp::CreateTime(millis) => millis, + Timestamp::LogAppendTime(millis) => millis, + Timestamp::NotAvailable => SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default() + .as_millis() as i64, + }; + + let event: UserOpEvent = serde_json::from_slice(payload)?; + + debug!( + user_op_hash = %event.user_op_hash(), + timestamp = timestamp, + offset = message.offset(), + partition = message.partition(), + "Received UserOp event" + ); + + self.last_message_offset = Some(message.offset()); + self.last_message_partition = Some(message.partition()); + + let key = message + .key() + .map(|k| String::from_utf8_lossy(k).to_string()) + .ok_or_else(|| anyhow::anyhow!("Message missing required key"))?; + + Ok(UserOpEventWrapper { + key, + event, + timestamp, + }) + } + Err(e) => { + error!(error = %e, "Error receiving UserOp message from Kafka"); + sleep(Duration::from_secs(1)).await; + Err(e.into()) + } + } + } + + async fn commit(&mut self) -> Result<()> { + if let (Some(offset), Some(partition)) = + (self.last_message_offset, self.last_message_partition) + { + let mut tpl = TopicPartitionList::new(); + tpl.add_partition_offset(&self.topic, partition, rdkafka::Offset::Offset(offset + 1))?; + self.consumer + .commit(&tpl, rdkafka::consumer::CommitMode::Async)?; + } + Ok(()) + } +} diff --git a/crates/audit/tests/integration_tests.rs b/crates/audit/tests/integration_tests.rs index bb79d24d..25f35d9a 100644 --- a/crates/audit/tests/integration_tests.rs +++ b/crates/audit/tests/integration_tests.rs @@ -1,9 +1,13 @@ +use alloy_primitives::{Address, B256, U256}; use std::time::Duration; use tips_audit::{ - KafkaAuditArchiver, KafkaAuditLogReader, - publisher::{BundleEventPublisher, KafkaBundleEventPublisher}, + KafkaAuditArchiver, KafkaAuditLogReader, KafkaUserOpAuditLogReader, UserOpEventReader, + publisher::{ + BundleEventPublisher, KafkaBundleEventPublisher, KafkaUserOpEventPublisher, + UserOpEventPublisher, + }, storage::{BundleEventS3Reader, S3EventReaderWriter}, - types::{BundleEvent, DropReason}, + types::{BundleEvent, DropReason, UserOpEvent}, }; use tips_core::test_utils::create_bundle_from_txn_data; use uuid::Uuid; @@ -71,3 +75,50 @@ async fn test_kafka_publisher_s3_archiver_integration() Ok(()) } + +#[tokio::test] +async fn test_userop_kafka_publisher_reader_integration() +-> Result<(), Box> { + let harness = TestHarness::new().await?; + let topic = "test-userop-events"; + + let test_user_op_hash = B256::from_slice(&[1u8; 32]); + let test_sender = Address::from_slice(&[2u8; 20]); + let test_entry_point = Address::from_slice(&[3u8; 20]); + let test_nonce = U256::from(42); + + let test_event = UserOpEvent::AddedToMempool { + user_op_hash: test_user_op_hash, + sender: test_sender, + entry_point: test_entry_point, + nonce: test_nonce, + }; + + let publisher = KafkaUserOpEventPublisher::new(harness.kafka_producer, topic.to_string()); + publisher.publish(test_event.clone()).await?; + + let mut reader = KafkaUserOpAuditLogReader::new(harness.kafka_consumer, topic.to_string())?; + + let received = tokio::time::timeout(Duration::from_secs(10), reader.read_event()).await??; + + assert_eq!(received.event.user_op_hash(), test_user_op_hash); + + match received.event { + UserOpEvent::AddedToMempool { + user_op_hash, + sender, + entry_point, + nonce, + } => { + assert_eq!(user_op_hash, test_user_op_hash); + assert_eq!(sender, test_sender); + assert_eq!(entry_point, test_entry_point); + assert_eq!(nonce, test_nonce); + } + _ => panic!("Expected AddedToMempool event"), + } + + reader.commit().await?; + + Ok(()) +} From 035b7d0eb9da8bb343420d7ee8c5b52586c33e42 Mon Sep 17 00:00:00 2001 From: Andrei De Stefani Date: Tue, 16 Dec 2025 18:17:30 +0100 Subject: [PATCH 2/3] Quick draft of mempool interface --- crates/account-abstraction-core/Cargo.toml | 4 +- .../core/src/account_abstraction_service.rs | 45 +- .../core/src/entrypoints/mod.rs | 3 + .../core/src/entrypoints/v06.rs | 139 ++++++ .../core/src/entrypoints/v07.rs | 180 ++++++++ .../core/src/entrypoints/version.rs | 31 ++ .../account-abstraction-core/core/src/lib.rs | 5 +- .../core/src/mempool.rs | 403 ++++++++++++++++++ .../core/src/types.rs | 260 ++++++----- 9 files changed, 952 insertions(+), 118 deletions(-) create mode 100644 crates/account-abstraction-core/core/src/entrypoints/mod.rs create mode 100644 crates/account-abstraction-core/core/src/entrypoints/v06.rs create mode 100644 crates/account-abstraction-core/core/src/entrypoints/v07.rs create mode 100644 crates/account-abstraction-core/core/src/entrypoints/version.rs create mode 100644 crates/account-abstraction-core/core/src/mempool.rs diff --git a/crates/account-abstraction-core/Cargo.toml b/crates/account-abstraction-core/Cargo.toml index a16a79db..55277ca7 100644 --- a/crates/account-abstraction-core/Cargo.toml +++ b/crates/account-abstraction-core/Cargo.toml @@ -9,7 +9,6 @@ edition.workspace = true [lib] path = "core/src/lib.rs" - [dependencies] alloy-serde = { version = "1.0.41", default-features = false } serde.workspace = true @@ -21,9 +20,10 @@ reth-rpc-eth-types.workspace = true tokio.workspace = true jsonrpsee.workspace = true async-trait = { workspace = true } +alloy-sol-types.workspace= true +anyhow.workspace = true [dev-dependencies] alloy-primitives.workspace = true serde_json.workspace = true wiremock.workspace = true - diff --git a/crates/account-abstraction-core/core/src/account_abstraction_service.rs b/crates/account-abstraction-core/core/src/account_abstraction_service.rs index 0cba40dd..d6c65a05 100644 --- a/crates/account-abstraction-core/core/src/account_abstraction_service.rs +++ b/crates/account-abstraction-core/core/src/account_abstraction_service.rs @@ -1,4 +1,5 @@ -use crate::types::{UserOperationRequest, UserOperationRequestValidationResult}; +use crate::types::{ValidationResult, VersionedUserOperation}; +use alloy_primitives::Address; use alloy_provider::{Provider, RootProvider}; use async_trait::async_trait; use jsonrpsee::core::RpcResult; @@ -10,8 +11,9 @@ use tokio::time::{Duration, timeout}; pub trait AccountAbstractionService: Send + Sync { async fn validate_user_operation( &self, - user_operation: UserOperationRequest, - ) -> RpcResult; + user_operation: &VersionedUserOperation, + entry_point: &Address, + ) -> RpcResult; } #[derive(Debug, Clone)] @@ -24,11 +26,13 @@ pub struct AccountAbstractionServiceImpl { impl AccountAbstractionService for AccountAbstractionServiceImpl { async fn validate_user_operation( &self, - user_operation: UserOperationRequest, - ) -> RpcResult { + user_operation: &VersionedUserOperation, + entry_point: &Address, + ) -> RpcResult { // Steps: Reputation Service Validate // Steps: Base Node Validate User Operation - self.base_node_validate_user_operation(user_operation).await + self.base_node_validate_user_operation(user_operation, entry_point) + .await } } @@ -45,17 +49,18 @@ impl AccountAbstractionServiceImpl { pub async fn base_node_validate_user_operation( &self, - user_operation: UserOperationRequest, - ) -> RpcResult { + user_operation: &VersionedUserOperation, + entry_point: &Address, + ) -> RpcResult { let result = timeout( Duration::from_secs(self.validate_user_operation_timeout), self.simulation_provider .client() - .request("base_validateUserOperation", (user_operation,)), + .request("base_validateUserOperation", (user_operation, entry_point)), ) .await; - let validation_result: UserOperationRequestValidationResult = match result { + let validation_result: ValidationResult = match result { Err(_) => { return Err( EthApiError::InvalidParams("Timeout on requesting validation".into()) @@ -88,8 +93,8 @@ mod tests { MockServer::start().await } - fn new_test_user_operation_v06() -> UserOperationRequest { - UserOperationRequest::EntryPointV06(UserOperation { + fn new_test_user_operation_v06() -> VersionedUserOperation { + VersionedUserOperation::UserOperation(UserOperation { sender: Address::ZERO, nonce: U256::from(0), init_code: Bytes::default(), @@ -126,7 +131,7 @@ mod tests { let user_operation = new_test_user_operation_v06(); let result = service - .base_node_validate_user_operation(user_operation) + .base_node_validate_user_operation(&user_operation, &Address::ZERO) .await; assert!(result.is_err()); @@ -153,7 +158,7 @@ mod tests { let user_operation = new_test_user_operation_v06(); let result = service - .base_node_validate_user_operation(user_operation) + .base_node_validate_user_operation(&user_operation, &Address::ZERO) .await; assert!(result.is_err()); assert!(result.unwrap_err().to_string().contains("Internal error")); @@ -167,8 +172,11 @@ mod tests { "jsonrpc": "2.0", "id": 1, "result": { - "expirationTimestamp": 1000, - "gasUsed": "10000" + "valid": true, + "reason": null, + "valid_until": null, + "valid_after": null, + "context": null } }))) .mount(&mock_server) @@ -178,11 +186,10 @@ mod tests { let user_operation = new_test_user_operation_v06(); let result = service - .base_node_validate_user_operation(user_operation) + .base_node_validate_user_operation(&user_operation, &Address::ZERO) .await .unwrap(); - assert_eq!(result.expiration_timestamp, 1000); - assert_eq!(result.gas_used, U256::from(10_000)); + assert_eq!(result.valid, true); } } diff --git a/crates/account-abstraction-core/core/src/entrypoints/mod.rs b/crates/account-abstraction-core/core/src/entrypoints/mod.rs new file mode 100644 index 00000000..4946ba2e --- /dev/null +++ b/crates/account-abstraction-core/core/src/entrypoints/mod.rs @@ -0,0 +1,3 @@ +pub mod v06; +pub mod v07; +pub mod version; diff --git a/crates/account-abstraction-core/core/src/entrypoints/v06.rs b/crates/account-abstraction-core/core/src/entrypoints/v06.rs new file mode 100644 index 00000000..4883305d --- /dev/null +++ b/crates/account-abstraction-core/core/src/entrypoints/v06.rs @@ -0,0 +1,139 @@ +/* + * ERC-4337 v0.6 UserOperation Hash Calculation + * + * 1. Hash variable-length fields: initCode, callData, paymasterAndData + * 2. Pack all fields into struct (using hashes from step 1, gas values as uint256) + * 3. encodedHash = keccak256(abi.encode(packed struct)) + * 4. final hash = keccak256(abi.encode(encodedHash, entryPoint, chainId)) + * + * Reference: rundler/crates/types/src/user_operation/v0_6.rs:927-934 + */ +use alloy_primitives::{ChainId, U256}; +use alloy_rpc_types::erc4337; +use alloy_sol_types::{SolValue, sol}; +sol! { + #[allow(missing_docs)] + #[derive(Default, Debug, PartialEq, Eq)] + struct UserOperationHashEncoded { + bytes32 encodedHash; + address entryPoint; + uint256 chainId; + } + + #[allow(missing_docs)] + #[derive(Default, Debug, PartialEq, Eq)] + struct UserOperationPackedForHash { + address sender; + uint256 nonce; + bytes32 hashInitCode; + bytes32 hashCallData; + uint256 callGasLimit; + uint256 verificationGasLimit; + uint256 preVerificationGas; + uint256 maxFeePerGas; + uint256 maxPriorityFeePerGas; + bytes32 hashPaymasterAndData; + } +} + +impl From for UserOperationPackedForHash { + fn from(op: erc4337::UserOperation) -> UserOperationPackedForHash { + UserOperationPackedForHash { + sender: op.sender, + nonce: op.nonce, + hashInitCode: alloy_primitives::keccak256(op.init_code), + hashCallData: alloy_primitives::keccak256(op.call_data), + callGasLimit: U256::from(op.call_gas_limit), + verificationGasLimit: U256::from(op.verification_gas_limit), + preVerificationGas: U256::from(op.pre_verification_gas), + maxFeePerGas: U256::from(op.max_fee_per_gas), + maxPriorityFeePerGas: U256::from(op.max_priority_fee_per_gas), + hashPaymasterAndData: alloy_primitives::keccak256(op.paymaster_and_data), + } + } +} + +pub fn hash_user_operation( + user_operation: &erc4337::UserOperation, + entry_point: alloy_primitives::Address, + chain_id: ChainId, +) -> alloy_primitives::B256 { + let packed = UserOperationPackedForHash::from(user_operation.clone()); + let encoded = UserOperationHashEncoded { + encodedHash: alloy_primitives::keccak256(packed.abi_encode()), + entryPoint: entry_point, + chainId: U256::from(chain_id), + }; + alloy_primitives::keccak256(encoded.abi_encode()) +} + +#[cfg(test)] +mod tests { + use super::*; + use alloy_primitives::{Bytes, U256, address, b256, bytes}; + use alloy_rpc_types::erc4337; + + #[test] + fn test_hash_zeroed() { + let entry_point_address_v0_6 = address!("66a15edcc3b50a663e72f1457ffd49b9ae284ddc"); + let chain_id = 1337; + let user_op_with_zeroed_init_code = erc4337::UserOperation { + sender: address!("0x0000000000000000000000000000000000000000"), + nonce: U256::ZERO, + init_code: Bytes::default(), + call_data: Bytes::default(), + call_gas_limit: U256::from(0), + verification_gas_limit: U256::from(0), + pre_verification_gas: U256::from(0), + max_fee_per_gas: U256::from(0), + max_priority_fee_per_gas: U256::from(0), + paymaster_and_data: Bytes::default(), + signature: Bytes::default(), + }; + + let hash = hash_user_operation( + &user_op_with_zeroed_init_code, + entry_point_address_v0_6, + chain_id, + ); + assert_eq!( + hash, + b256!("dca97c3b49558ab360659f6ead939773be8bf26631e61bb17045bb70dc983b2d") + ); + } + + #[test] + fn test_hash_non_zeroed() { + let entry_point_address_v0_6 = address!("66a15edcc3b50a663e72f1457ffd49b9ae284ddc"); + let chain_id = 1337; + let user_op_with_non_zeroed_init_code = erc4337::UserOperation { + sender: address!("0x1306b01bc3e4ad202612d3843387e94737673f53"), + nonce: U256::from(8942), + init_code: "0x6942069420694206942069420694206942069420" + .parse() + .unwrap(), + call_data: "0x0000000000000000000000000000000000000000080085" + .parse() + .unwrap(), + call_gas_limit: U256::from(10_000), + verification_gas_limit: U256::from(100_000), + pre_verification_gas: U256::from(100), + max_fee_per_gas: U256::from(99_999), + max_priority_fee_per_gas: U256::from(9_999_999), + paymaster_and_data: bytes!( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + ), + signature: bytes!("da0929f527cded8d0a1eaf2e8861d7f7e2d8160b7b13942f99dd367df4473a"), + }; + + let hash = hash_user_operation( + &user_op_with_non_zeroed_init_code, + entry_point_address_v0_6, + chain_id, + ); + assert_eq!( + hash, + b256!("484add9e4d8c3172d11b5feb6a3cc712280e176d278027cfa02ee396eb28afa1") + ); + } +} diff --git a/crates/account-abstraction-core/core/src/entrypoints/v07.rs b/crates/account-abstraction-core/core/src/entrypoints/v07.rs new file mode 100644 index 00000000..60d8fd46 --- /dev/null +++ b/crates/account-abstraction-core/core/src/entrypoints/v07.rs @@ -0,0 +1,180 @@ +/* + * ERC-4337 v0.7 UserOperation Hash Calculation + * + * 1. Hash variable-length fields: initCode, callData, paymasterAndData + * 2. Pack all fields into struct (using hashes from step 1, gas values as bytes32) + * 3. encodedHash = keccak256(abi.encode(packed struct)) + * 4. final hash = keccak256(abi.encode(encodedHash, entryPoint, chainId)) + * + * Reference: rundler/crates/types/src/user_operation/v0_7.rs:1094-1123 + */ +use alloy_primitives::{Address, ChainId, FixedBytes, U256}; +use alloy_primitives::{Bytes, keccak256}; +use alloy_rpc_types::erc4337; +use alloy_sol_types::{SolValue, sol}; + +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; + bytes signature; + } + + #[derive(Default, Debug, PartialEq, Eq)] + struct UserOperationHashEncoded { + bytes32 encodedHash; + address entryPoint; + uint256 chainId; + } + + #[derive(Default, Debug, PartialEq, Eq)] + struct UserOperationPackedForHash { + address sender; + uint256 nonce; + bytes32 hashInitCode; + bytes32 hashCallData; + bytes32 accountGasLimits; + uint256 preVerificationGas; + bytes32 gasFees; + bytes32 hashPaymasterAndData; + } +); + +impl From for PackedUserOperation { + fn from(uo: erc4337::PackedUserOperation) -> Self { + let init_code = if let Some(factory) = uo.factory { + let mut init_code = factory.to_vec(); + init_code.extend_from_slice(&uo.factory_data.clone().unwrap_or_default()); + Bytes::from(init_code) + } else { + Bytes::new() + }; + let account_gas_limits = + pack_u256_pair_to_bytes32(uo.verification_gas_limit, uo.call_gas_limit); + let gas_fees = pack_u256_pair_to_bytes32(uo.max_priority_fee_per_gas, uo.max_fee_per_gas); + let pvgl: [u8; 16] = uo + .paymaster_verification_gas_limit + .unwrap_or_default() + .to::() + .to_be_bytes(); + let pogl: [u8; 16] = uo + .paymaster_post_op_gas_limit + .unwrap_or_default() + .to::() + .to_be_bytes(); + let paymaster_and_data = if let Some(paymaster) = uo.paymaster { + let mut paymaster_and_data = paymaster.to_vec(); + paymaster_and_data.extend_from_slice(&pvgl); + paymaster_and_data.extend_from_slice(&pogl); + paymaster_and_data.extend_from_slice(&uo.paymaster_data.unwrap()); + Bytes::from(paymaster_and_data) + } else { + Bytes::new() + }; + PackedUserOperation { + sender: uo.sender, + nonce: uo.nonce, + initCode: init_code, + callData: uo.call_data.clone(), + accountGasLimits: account_gas_limits, + preVerificationGas: U256::from(uo.pre_verification_gas), + gasFees: gas_fees, + paymasterAndData: paymaster_and_data, + signature: uo.signature.clone(), + } + } +} +fn pack_u256_pair_to_bytes32(high: U256, low: U256) -> FixedBytes<32> { + let mask = (U256::from(1u64) << 128) - U256::from(1u64); + let hi = high & mask; + let lo = low & mask; + let combined: U256 = (hi << 128) | lo; + FixedBytes::from(combined.to_be_bytes::<32>()) +} + +fn hash_packed_user_operation( + puo: &PackedUserOperation, + entry_point: Address, + chain_id: u64, +) -> FixedBytes<32> { + let hash_init_code = alloy_primitives::keccak256(&puo.initCode); + let hash_call_data = alloy_primitives::keccak256(&puo.callData); + let hash_paymaster_and_data = alloy_primitives::keccak256(&puo.paymasterAndData); + + let packed_for_hash = UserOperationPackedForHash { + sender: puo.sender, + nonce: puo.nonce, + hashInitCode: hash_init_code, + hashCallData: hash_call_data, + accountGasLimits: puo.accountGasLimits, + preVerificationGas: puo.preVerificationGas, + gasFees: puo.gasFees, + hashPaymasterAndData: hash_paymaster_and_data, + }; + + let hashed = alloy_primitives::keccak256(packed_for_hash.abi_encode()); + + let encoded = UserOperationHashEncoded { + encodedHash: hashed, + entryPoint: entry_point, + chainId: U256::from(chain_id), + }; + + keccak256(encoded.abi_encode()) +} + +pub fn hash_user_operation( + user_operation: &erc4337::PackedUserOperation, + entry_point: Address, + chain_id: ChainId, +) -> FixedBytes<32> { + let packed = PackedUserOperation::from(user_operation.clone()); + hash_packed_user_operation(&packed, entry_point, chain_id) +} + +#[cfg(test)] +mod test { + use super::*; + use alloy_primitives::{Bytes, U256}; + use alloy_primitives::{address, b256, bytes, uint}; + + #[test] + fn test_hash() { + let puo = PackedUserOperation { + sender: address!("b292Cf4a8E1fF21Ac27C4f94071Cd02C022C414b"), + nonce: uint!(0xF83D07238A7C8814A48535035602123AD6DBFA63000000000000000000000001_U256), + initCode: Bytes::default(), // Empty + callData: + bytes!("e9ae5c53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000 + 0000000000000000000000000000000000001d8b292cf4a8e1ff21ac27c4f94071cd02c022c414b00000000000000000000000000000000000000000000000000000000000000009517e29f000000000000000000 + 0000000000000000000000000000000000000000000002000000000000000000000000ad6330089d9a1fe89f4020292e1afe9969a5a2fc00000000000000000000000000000000000000000000000000000000000 + 0006000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000015180000000000000000000000000000000000000 + 00000000000000000000000000000000000000000000000000000000000000000000000000000000018e2fbe898000000000000000000000000000000000000000000000000000000000000000800000000000000 + 0000000000000000000000000000000000000000000000000800000000000000000000000002372912728f93ab3daaaebea4f87e6e28476d987000000000000000000000000000000000000000000000000002386 + f26fc10000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000"), + accountGasLimits: b256!("000000000000000000000000000114fc0000000000000000000000000012c9b5"), + preVerificationGas: U256::from(48916), + gasFees: b256!("000000000000000000000000524121000000000000000000000000109a4a441a"), + paymasterAndData: Bytes::default(), // Empty + signature: bytes!("3c7bfe22c9c2ef8994a9637bcc4df1741c5dc0c25b209545a7aeb20f7770f351479b683bd17c4d55bc32e2a649c8d2dff49dcfcc1f3fd837bcd88d1e69a434cf1c"), + }; + + let expected_hash = + b256!("e486401370d145766c3cf7ba089553214a1230d38662ae532c9b62eb6dadcf7e"); + let uo = hash_packed_user_operation( + &puo, + address!("0x0000000071727De22E5E9d8BAf0edAc6f37da032"), + 11155111, + ); + + assert_eq!(uo, expected_hash); + } +} diff --git a/crates/account-abstraction-core/core/src/entrypoints/version.rs b/crates/account-abstraction-core/core/src/entrypoints/version.rs new file mode 100644 index 00000000..ae37e5d4 --- /dev/null +++ b/crates/account-abstraction-core/core/src/entrypoints/version.rs @@ -0,0 +1,31 @@ +use alloy_primitives::{Address, address}; + +#[derive(Debug, Clone)] +pub enum EntryPointVersion { + V06, + V07, +} + +impl EntryPointVersion { + pub const V06_ADDRESS: Address = address!("0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789"); + pub const V07_ADDRESS: Address = address!("0x0000000071727De22E5E9d8BAf0edAc6f37da032"); +} + +#[derive(Debug)] +pub struct UnknownEntryPointAddress { + pub address: Address, +} + +impl TryFrom
for EntryPointVersion { + type Error = UnknownEntryPointAddress; + + fn try_from(addr: Address) -> Result { + if addr == Self::V06_ADDRESS { + Ok(EntryPointVersion::V06) + } else if addr == Self::V07_ADDRESS { + Ok(EntryPointVersion::V07) + } else { + Err(UnknownEntryPointAddress { address: addr }) + } + } +} diff --git a/crates/account-abstraction-core/core/src/lib.rs b/crates/account-abstraction-core/core/src/lib.rs index bb2abc37..b3aa2f76 100644 --- a/crates/account-abstraction-core/core/src/lib.rs +++ b/crates/account-abstraction-core/core/src/lib.rs @@ -1,5 +1,6 @@ pub mod account_abstraction_service; +pub mod entrypoints; pub mod types; - pub use account_abstraction_service::{AccountAbstractionService, AccountAbstractionServiceImpl}; -pub use types::{SendUserOperationResponse, UserOperationRequest}; +pub use types::{SendUserOperationResponse, VersionedUserOperation}; +pub mod mempool; diff --git a/crates/account-abstraction-core/core/src/mempool.rs b/crates/account-abstraction-core/core/src/mempool.rs new file mode 100644 index 00000000..3cc274f7 --- /dev/null +++ b/crates/account-abstraction-core/core/src/mempool.rs @@ -0,0 +1,403 @@ +use crate::types::{PoolOperation, UserOpHash}; +use std::collections::{BTreeSet, HashMap}; +use std::sync::Arc; +use std::sync::atomic::AtomicU64; +use std::sync::atomic::Ordering; + +pub struct PoolConfig { + minimum_max_fee_per_gas: u128, +} + +#[derive(Eq, PartialEq, Clone, Debug)] +pub struct OrderedPoolOperation { + pub pool_operation: PoolOperation, + pub submission_id: u64, + pub priority_order: u64, +} + +impl Ord for OrderedPoolOperation { + /// TODO: There can be invalid opperations, where base fee, + expected gas price + /// is greater that the maximum gas, in that case we don't include it in the mempool as such mempool changes. + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + other + .pool_operation + .operation + .max_priority_fee_per_gas() + .cmp(&self.pool_operation.operation.max_priority_fee_per_gas()) + .then_with(|| self.submission_id.cmp(&other.submission_id)) + } +} + +impl PartialOrd for OrderedPoolOperation { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl OrderedPoolOperation { + pub fn create_from_pool_operation(operation: &PoolOperation, submission_id: u64) -> Self { + Self { + pool_operation: operation.clone(), + priority_order: submission_id, + submission_id, + } + } +} + +pub trait Mempool { + fn add_operation( + &mut self, + operation: &PoolOperation, + ) -> Result, anyhow::Error>; + fn get_top_operations(&self, n: usize) -> impl Iterator>; + fn remove_operation( + &mut self, + operation_hash: &UserOpHash, + ) -> Result, anyhow::Error>; +} + +pub struct MempoolImpl { + config: PoolConfig, + best: BTreeSet, + hash_to_operation: HashMap, + submission_id_counter: AtomicU64, +} + +impl Mempool for MempoolImpl { + fn add_operation( + &mut self, + operation: &PoolOperation, + ) -> Result, anyhow::Error> { + if operation.operation.max_fee_per_gas() < self.config.minimum_max_fee_per_gas { + return Err(anyhow::anyhow!( + "Gas price is below the minimum required PVG gas" + )); + } + let ordered_operation_result = self.handle_add_operation(operation)?; + Ok(ordered_operation_result) + } + + fn get_top_operations(&self, n: usize) -> impl Iterator> { + self.best + .iter() + .take(n) + .map(|o| Arc::new(o.pool_operation.clone())) + } + + fn remove_operation( + &mut self, + operation_hash: &UserOpHash, + ) -> Result, anyhow::Error> { + if let Some(ordered_operation) = self.hash_to_operation.remove(operation_hash) { + self.best.remove(&ordered_operation); + Ok(Some(ordered_operation.pool_operation)) + } else { + Ok(None) + } + } +} + +impl MempoolImpl { + fn handle_add_operation( + &mut self, + operation: &PoolOperation, + ) -> Result, anyhow::Error> { + if let Some(old_ordered_operation) = self.hash_to_operation.get(&operation.hash) { + if operation.should_replace(&old_ordered_operation.pool_operation) { + self.best.remove(old_ordered_operation); + self.hash_to_operation.remove(&operation.hash); + } else { + return Ok(None); + } + } + + let order = self.get_next_order_id(); + let ordered_operation = OrderedPoolOperation::create_from_pool_operation(operation, order); + + self.best.insert(ordered_operation.clone()); + self.hash_to_operation + .insert(operation.hash, ordered_operation.clone()); + Ok(Some(ordered_operation)) + } + + fn get_next_order_id(&self) -> u64 { + self.submission_id_counter.fetch_add(1, Ordering::SeqCst) + } + + pub fn new(config: PoolConfig) -> Self { + Self { + config, + best: BTreeSet::new(), + hash_to_operation: HashMap::new(), + submission_id_counter: AtomicU64::new(0), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::types::VersionedUserOperation; + use alloy_primitives::{Address, FixedBytes, Uint}; + use alloy_rpc_types::erc4337; + fn create_test_user_operation(max_priority_fee_per_gas: u128) -> VersionedUserOperation { + VersionedUserOperation::UserOperation(erc4337::UserOperation { + sender: Address::ZERO, + nonce: Uint::from(0), + init_code: Default::default(), + call_data: Default::default(), + call_gas_limit: Uint::from(100000), + verification_gas_limit: Uint::from(100000), + pre_verification_gas: Uint::from(21000), + max_fee_per_gas: Uint::from(max_priority_fee_per_gas), + max_priority_fee_per_gas: Uint::from(max_priority_fee_per_gas), + paymaster_and_data: Default::default(), + signature: Default::default(), + }) + } + + fn create_pool_operation(max_priority_fee_per_gas: u128, hash: UserOpHash) -> PoolOperation { + PoolOperation { + operation: create_test_user_operation(max_priority_fee_per_gas), + hash, + } + } + + fn create_test_mempool(minimum_required_pvg_gas: u128) -> MempoolImpl { + MempoolImpl::new(PoolConfig { + minimum_max_fee_per_gas: minimum_required_pvg_gas, + }) + } + + // Tests successfully adding a valid operation to the mempool + #[test] + fn test_add_operation_success() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + let operation = create_pool_operation(2000, hash); + + let result = mempool.add_operation(&operation); + + assert!(result.is_ok()); + let ordered_op = result.unwrap(); + assert!(ordered_op.is_some()); + let ordered_op = ordered_op.unwrap(); + assert_eq!(ordered_op.pool_operation.hash, hash); + assert_eq!( + ordered_op.pool_operation.operation.max_fee_per_gas(), + Uint::from(2000) + ); + } + + // Tests adding an operation with a gas price below the minimum required PVG gas + #[test] + fn test_add_operation_below_minimum_gas() { + let mut mempool = create_test_mempool(2000); + let hash = FixedBytes::from([1u8; 32]); + let operation = create_pool_operation(1000, hash); + + let result = mempool.add_operation(&operation); + + assert!(result.is_err()); + assert!( + result + .unwrap_err() + .to_string() + .contains("Gas price is below the minimum required PVG gas") + ); + } + + // Tests adding an operation with the same hash but higher gas price + #[test] + fn test_add_operation_duplicate_hash_higher_gas() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + + let operation1 = create_pool_operation(2000, hash); + let result1 = mempool.add_operation(&operation1); + assert!(result1.is_ok()); + assert!(result1.unwrap().is_some()); + + let operation2 = create_pool_operation(3000, hash); + let result2 = mempool.add_operation(&operation2); + assert!(result2.is_ok()); + assert!(result2.unwrap().is_some()); + } + + // Tests adding an operation with the same hash but lower gas price + #[test] + fn test_add_operation_duplicate_hash_lower_gas() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + + let operation1 = create_pool_operation(3000, hash); + let result1 = mempool.add_operation(&operation1); + assert!(result1.is_ok()); + assert!(result1.unwrap().is_some()); + + let operation2 = create_pool_operation(2000, hash); + let result2 = mempool.add_operation(&operation2); + assert!(result2.is_ok()); + assert!(result2.unwrap().is_none()); + } + + // Tests adding an operation with the same hash and equal gas price + #[test] + fn test_add_operation_duplicate_hash_equal_gas() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + + let operation1 = create_pool_operation(2000, hash); + let result1 = mempool.add_operation(&operation1); + assert!(result1.is_ok()); + assert!(result1.unwrap().is_some()); + + let operation2 = create_pool_operation(2000, hash); + let result2 = mempool.add_operation(&operation2); + assert!(result2.is_ok()); + assert!(result2.unwrap().is_none()); + } + + // Tests adding multiple operations with different hashes + #[test] + fn test_add_multiple_operations_with_different_hashes() { + let mut mempool = create_test_mempool(1000); + + let hash1 = FixedBytes::from([1u8; 32]); + let operation1 = create_pool_operation(2000, hash1); + let result1 = mempool.add_operation(&operation1); + assert!(result1.is_ok()); + assert!(result1.unwrap().is_some()); + + let hash2 = FixedBytes::from([2u8; 32]); + let operation2 = create_pool_operation(3000, hash2); + let result2 = mempool.add_operation(&operation2); + assert!(result2.is_ok()); + assert!(result2.unwrap().is_some()); + + let hash3 = FixedBytes::from([3u8; 32]); + let operation3 = create_pool_operation(1500, hash3); + let result3 = mempool.add_operation(&operation3); + assert!(result3.is_ok()); + assert!(result3.unwrap().is_some()); + + assert_eq!(mempool.hash_to_operation.len(), 3); + assert_eq!(mempool.best.len(), 3); + } + + // Tests removing an operation that is not in the mempool + #[test] + fn test_remove_operation_not_in_mempool() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + + let result = mempool.remove_operation(&hash); + assert!(result.is_ok()); + assert!(result.unwrap().is_none()); + } + + // Tests removing an operation that exists in the mempool + #[test] + fn test_remove_operation_exists() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + let operation = create_pool_operation(2000, hash); + + mempool.add_operation(&operation).unwrap(); + + let result = mempool.remove_operation(&hash); + assert!(result.is_ok()); + let removed = result.unwrap(); + assert!(removed.is_some()); + let removed_op = removed.unwrap(); + assert_eq!(removed_op.hash, hash); + assert_eq!(removed_op.operation.max_fee_per_gas(), Uint::from(2000)); + } + + // Tests removing an operation and checking the best operations + #[test] + fn test_remove_operation_and_check_best() { + let mut mempool = create_test_mempool(1000); + let hash = FixedBytes::from([1u8; 32]); + let operation = create_pool_operation(2000, hash); + + mempool.add_operation(&operation).unwrap(); + + let best_before: Vec<_> = mempool.get_top_operations(10).collect(); + assert_eq!(best_before.len(), 1); + assert_eq!(best_before[0].hash, hash); + + let result = mempool.remove_operation(&hash); + assert!(result.is_ok()); + assert!(result.unwrap().is_some()); + + let best_after: Vec<_> = mempool.get_top_operations(10).collect(); + assert_eq!(best_after.len(), 0); + } + + // Tests getting the top operations with ordering + #[test] + fn test_get_top_operations_ordering() { + let mut mempool = create_test_mempool(1000); + + let hash1 = FixedBytes::from([1u8; 32]); + let operation1 = create_pool_operation(2000, hash1); + mempool.add_operation(&operation1).unwrap(); + + let hash2 = FixedBytes::from([2u8; 32]); + let operation2 = create_pool_operation(3000, hash2); + mempool.add_operation(&operation2).unwrap(); + + let hash3 = FixedBytes::from([3u8; 32]); + let operation3 = create_pool_operation(1500, hash3); + mempool.add_operation(&operation3).unwrap(); + + let best: Vec<_> = mempool.get_top_operations(10).collect(); + assert_eq!(best.len(), 3); + assert_eq!(best[0].operation.max_fee_per_gas(), Uint::from(3000)); + assert_eq!(best[1].operation.max_fee_per_gas(), Uint::from(2000)); + assert_eq!(best[2].operation.max_fee_per_gas(), Uint::from(1500)); + } + + // Tests getting the top operations with a limit + #[test] + fn test_get_top_operations_limit() { + let mut mempool = create_test_mempool(1000); + + let hash1 = FixedBytes::from([1u8; 32]); + let operation1 = create_pool_operation(2000, hash1); + mempool.add_operation(&operation1).unwrap(); + + let hash2 = FixedBytes::from([2u8; 32]); + let operation2 = create_pool_operation(3000, hash2); + mempool.add_operation(&operation2).unwrap(); + + let hash3 = FixedBytes::from([3u8; 32]); + let operation3 = create_pool_operation(1500, hash3); + mempool.add_operation(&operation3).unwrap(); + + let best: Vec<_> = mempool.get_top_operations(2).collect(); + assert_eq!(best.len(), 2); + assert_eq!(best[0].operation.max_fee_per_gas(), Uint::from(3000)); + assert_eq!(best[1].operation.max_fee_per_gas(), Uint::from(2000)); + } + + // Tests top opperations tie breaker with submission id + #[test] + fn test_get_top_operations_submission_id_tie_breaker() { + let mut mempool = create_test_mempool(1000); + + let hash1 = FixedBytes::from([1u8; 32]); + let operation1 = create_pool_operation(2000, hash1); + mempool.add_operation(&operation1).unwrap().unwrap(); + + let hash2 = FixedBytes::from([2u8; 32]); + let operation2 = create_pool_operation(2000, hash2); + mempool.add_operation(&operation2).unwrap().unwrap(); + + let best: Vec<_> = mempool.get_top_operations(2).collect(); + assert_eq!(best.len(), 2); + assert_eq!(best[0].hash, hash1); + assert_eq!(best[1].hash, hash2); + } +} diff --git a/crates/account-abstraction-core/core/src/types.rs b/crates/account-abstraction-core/core/src/types.rs index 27e6303f..8b8f0314 100644 --- a/crates/account-abstraction-core/core/src/types.rs +++ b/crates/account-abstraction-core/core/src/types.rs @@ -1,15 +1,56 @@ -use alloy_primitives::U256; +use crate::entrypoints::{v06, v07, version::EntryPointVersion}; +use alloy_primitives::{Address, B256, ChainId, FixedBytes, U256}; use alloy_rpc_types::erc4337; +pub use alloy_rpc_types::erc4337::SendUserOperationResponse; +use anyhow::Result; use serde::{Deserialize, Serialize}; -// Re-export SendUserOperationResponse -pub use alloy_rpc_types::erc4337::SendUserOperationResponse; +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(untagged)] +pub enum VersionedUserOperation { + UserOperation(erc4337::UserOperation), + PackedUserOperation(erc4337::PackedUserOperation), +} + +impl VersionedUserOperation { + pub fn max_fee_per_gas(&self) -> U256 { + match self { + VersionedUserOperation::UserOperation(op) => op.max_fee_per_gas, + VersionedUserOperation::PackedUserOperation(op) => op.max_fee_per_gas, + } + } + pub fn max_priority_fee_per_gas(&self) -> U256 { + match self { + VersionedUserOperation::UserOperation(op) => op.max_priority_fee_per_gas, + VersionedUserOperation::PackedUserOperation(op) => op.max_priority_fee_per_gas, + } + } +} #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] -#[serde(tag = "type")] -pub enum UserOperationRequest { - EntryPointV06(erc4337::UserOperation), - EntryPointV07(erc4337::PackedUserOperation), +pub struct UserOperationRequest { + pub user_operation: VersionedUserOperation, + pub entry_point: Address, + pub chain_id: ChainId, +} + +impl UserOperationRequest { + pub fn hash(&self) -> Result { + let entry_point_version = EntryPointVersion::try_from(self.entry_point) + .map_err(|_| anyhow::anyhow!("Unknown entry point version: {:#x}", self.entry_point))?; + + match (&self.user_operation, entry_point_version) { + (VersionedUserOperation::UserOperation(op), EntryPointVersion::V06) => Ok( + v06::hash_user_operation(op, self.entry_point, self.chain_id), + ), + (VersionedUserOperation::PackedUserOperation(op), EntryPointVersion::V07) => Ok( + v07::hash_user_operation(op, self.entry_point, self.chain_id), + ), + _ => Err(anyhow::anyhow!( + "Mismatched operation type and entry point version" + )), + } + } } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -19,33 +60,96 @@ pub struct UserOperationRequestValidationResult { pub gas_used: U256, } +/// Validation result for User Operations +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ValidationResult { + /// Whether the UserOp is valid + pub valid: bool, + /// Error message if not valid + #[serde(skip_serializing_if = "Option::is_none")] + pub reason: Option, + /// Timestamp until the UserOp is valid (0 = no expiry) + #[serde(skip_serializing_if = "Option::is_none")] + pub valid_until: Option, + /// Timestamp after which the UserOp is valid (0 = immediately) + #[serde(skip_serializing_if = "Option::is_none")] + pub valid_after: Option, + /// Entity stake/deposit context + #[serde(skip_serializing_if = "Option::is_none")] + pub context: Option, +} + +/// Entity stake/deposit information context +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct ValidationContext { + /// Sender (account) stake info + pub sender_info: EntityStakeInfo, + /// Factory stake info (if present) + #[serde(skip_serializing_if = "Option::is_none")] + pub factory_info: Option, + /// Paymaster stake info (if present) + #[serde(skip_serializing_if = "Option::is_none")] + pub paymaster_info: Option, + /// Aggregator stake info (if present) + #[serde(skip_serializing_if = "Option::is_none")] + pub aggregator_info: Option, +} + +/// Stake info for an entity (used in RPC response) +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EntityStakeInfo { + /// Entity address + pub address: Address, + /// Amount staked + pub stake: U256, + /// Unstake delay in seconds + pub unstake_delay_sec: u64, + /// Amount deposited for gas + pub deposit: U256, + /// Whether entity meets staking requirements + pub is_staked: bool, +} + +/// Aggregator stake info (used in RPC response) +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct AggregatorInfo { + /// Aggregator address + pub aggregator: Address, + /// Stake info + pub stake_info: EntityStakeInfo, +} + +pub type UserOpHash = FixedBytes<32>; + +#[derive(Eq, PartialEq, Clone, Debug)] +pub struct PoolOperation { + pub operation: VersionedUserOperation, + pub hash: UserOpHash, +} + +impl PoolOperation { + pub fn should_replace(&self, other: &PoolOperation) -> bool { + self.operation.max_fee_per_gas() > other.operation.max_fee_per_gas() + } +} + // Tests #[cfg(test)] mod tests { use std::str::FromStr; use super::*; - use alloy_primitives::{Address, Bytes, Uint}; - #[test] - fn should_throw_error_when_deserializing_invalid() { - const TEST_INVALID_USER_OPERATION: &str = r#" - { - "type": "EntryPointV06", - "sender": "0x1111111111111111111111111111111111111111", - "nonce": "0x0", - "callGasLimit": "0x5208" - } - "#; - let user_operation: Result = - serde_json::from_str::(TEST_INVALID_USER_OPERATION); - assert!(user_operation.is_err()); - } + use alloy_primitives::{Address, Uint}; #[test] - fn should_deserialize_v06() { - const TEST_USER_OPERATION: &str = r#" + fn deser_untagged_user_operation_without_type_field() { + // v0.6 shape, no "type" key + let json = r#" { - "type": "EntryPointV06", "sender": "0x1111111111111111111111111111111111111111", "nonce": "0x0", "initCode": "0x", @@ -58,90 +162,56 @@ mod tests { "paymasterAndData": "0x", "signature": "0x01" } - "#; - let user_operation: Result = - serde_json::from_str::(TEST_USER_OPERATION); - if user_operation.is_err() { - panic!("Error: {:?}", user_operation.err()); - } - let user_operation = user_operation.unwrap(); - match user_operation { - UserOperationRequest::EntryPointV06(user_operation) => { + "#; + + let parsed: VersionedUserOperation = + serde_json::from_str(json).expect("should deserialize as v0.6"); + match parsed { + VersionedUserOperation::UserOperation(op) => { assert_eq!( - user_operation.sender, + op.sender, Address::from_str("0x1111111111111111111111111111111111111111").unwrap() ); - assert_eq!(user_operation.nonce, Uint::from(0)); - assert_eq!(user_operation.init_code, Bytes::from_str("0x").unwrap()); - assert_eq!(user_operation.call_data, Bytes::from_str("0x").unwrap()); - assert_eq!(user_operation.call_gas_limit, Uint::from(0x5208)); - assert_eq!(user_operation.verification_gas_limit, Uint::from(0x100000)); - assert_eq!(user_operation.pre_verification_gas, Uint::from(0x10000)); - assert_eq!(user_operation.max_fee_per_gas, Uint::from(0x59682f10)); - assert_eq!( - user_operation.max_priority_fee_per_gas, - Uint::from(0x3b9aca00) - ); - assert_eq!( - user_operation.paymaster_and_data, - Bytes::from_str("0x").unwrap() - ); - assert_eq!(user_operation.signature, Bytes::from_str("0x01").unwrap()); - } - _ => { - panic!("Expected EntryPointV06, got {:?}", user_operation); + assert_eq!(op.nonce, Uint::from(0)); } + other => panic!("expected UserOperation, got {:?}", other), } } #[test] - fn should_deserialize_v07() { - const TEST_PACKED_USER_OPERATION: &str = r#" + fn deser_untagged_packed_user_operation_without_type_field() { + // v0.7 shape, no "type" key + let json = r#" { - "type": "EntryPointV07", - "sender": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", - "nonce": "0x1", - "factory": "0x2222222222222222222222222222222222222222", - "factoryData": "0xabcdef1234560000000000000000000000000000000000000000000000000000", - "callData": "0xb61d27f600000000000000000000000000000000000000000000000000000000000000c8", - "callGasLimit": "0x2dc6c0", - "verificationGasLimit": "0x1e8480", - "preVerificationGas": "0x186a0", - "maxFeePerGas": "0x77359400", - "maxPriorityFeePerGas": "0x3b9aca00", - "paymaster": "0x3333333333333333333333333333333333333333", - "paymasterVerificationGasLimit": "0x186a0", - "paymasterPostOpGasLimit": "0x27100", - "paymasterData": "0xfafb00000000000000000000000000000000000000000000000000000000000064", - "signature": "0xa3c5f1b90014e68abbbdc42e4b77b9accc0b7e1c5d0b5bcde1a47ba8faba00ff55c9a7de12e98b731766e35f6c51ab25c9b58cc0e7c4a33f25e75c51c6ad3c3a" - } - "#; - let user_operation: Result = - serde_json::from_str::(TEST_PACKED_USER_OPERATION); - if user_operation.is_err() { - panic!("Error: {:?}", user_operation.err()); + "sender": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "nonce": "0x1", + "factory": "0x2222222222222222222222222222222222222222", + "factoryData": "0xabcdef1234560000000000000000000000000000000000000000000000000000", + "callData": "0xb61d27f600000000000000000000000000000000000000000000000000000000000000c8", + "callGasLimit": "0x2dc6c0", + "verificationGasLimit": "0x1e8480", + "preVerificationGas": "0x186a0", + "maxFeePerGas": "0x77359400", + "maxPriorityFeePerGas": "0x3b9aca00", + "paymaster": "0x3333333333333333333333333333333333333333", + "paymasterVerificationGasLimit": "0x186a0", + "paymasterPostOpGasLimit": "0x27100", + "paymasterData": "0xfafb00000000000000000000000000000000000000000000000000000000000064", + "signature": "0xa3c5f1b90014e68abbbdc42e4b77b9accc0b7e1c5d0b5bcde1a47ba8faba00ff55c9a7de12e98b731766e35f6c51ab25c9b58cc0e7c4a33f25e75c51c6ad3c3a" } - let user_operation = user_operation.unwrap(); - match user_operation { - UserOperationRequest::EntryPointV07(user_operation) => { + "#; + + let parsed: VersionedUserOperation = + serde_json::from_str(json).expect("should deserialize as v0.7 packed"); + match parsed { + VersionedUserOperation::PackedUserOperation(op) => { assert_eq!( - user_operation.sender, + op.sender, Address::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap() ); - assert_eq!(user_operation.nonce, Uint::from(1)); - assert_eq!( - user_operation.call_data, - alloy_primitives::bytes!( - "0xb61d27f600000000000000000000000000000000000000000000000000000000000000c8" - ) - ); - assert_eq!(user_operation.call_gas_limit, Uint::from(0x2dc6c0)); - assert_eq!(user_operation.verification_gas_limit, Uint::from(0x1e8480)); - assert_eq!(user_operation.pre_verification_gas, Uint::from(0x186a0)); - } - _ => { - panic!("Expected EntryPointV07, got {:?}", user_operation); + assert_eq!(op.nonce, Uint::from(1)); } + other => panic!("expected PackedUserOperation, got {:?}", other), } } } From d4e2b38fb0002ac79ec50934bccbef3b5b0d7b68 Mon Sep 17 00:00:00 2001 From: Andrei De Stefani Date: Tue, 16 Dec 2025 18:18:06 +0100 Subject: [PATCH 3/3] quick commit --- .cursor/rules/bugsnag/fix-bugsnag-issues.mdc | 72 +++++ .cursor/rules/coding-workflow.mdc | 19 ++ .cursor/rules/github/pr-template-format.mdc | 59 ++++ .cursor/rules/golang/coding-rules.mdc | 27 ++ .../rules/golang/english-and-comments-std.mdc | 49 ++++ .cursor/rules/golang/golang-naming-std.mdc | 69 +++++ .cursor/rules/golang/golang-use-getters.mdc | 53 ++++ .cursor/rules/golang/grpcclient.mdc | 17 ++ .../observability/logging-best-practices.mdc | 255 ++++++++++++++++++ .../observability/metrics-best-practices.mdc | 136 ++++++++++ .cursor/rules/python/api-design.mdc | 28 ++ .../rules/python/dependency-management.mdc | 21 ++ .../rules/python/distributed-computing.mdc | 25 ++ .cursor/rules/python/fastapi-standards.mdc | 41 +++ .cursor/rules/python/infrastructure.mdc | 25 ++ .../python/microservices-architecture.mdc | 36 +++ .cursor/rules/python/python-coding-rules.mdc | 32 +++ .cursor/rules/python/testing-standards.mdc | 28 ++ .cursor/rules/rego/rego-coding-patterns.mdc | 94 +++++++ .../Base Account Pull Request Guidelines.md | 172 ++++++++++++ context/Mini TDD - TIPS 4337 Bundler .docx | Bin 0 -> 306862 bytes 21 files changed, 1258 insertions(+) create mode 100644 .cursor/rules/bugsnag/fix-bugsnag-issues.mdc create mode 100644 .cursor/rules/coding-workflow.mdc create mode 100644 .cursor/rules/github/pr-template-format.mdc create mode 100644 .cursor/rules/golang/coding-rules.mdc create mode 100644 .cursor/rules/golang/english-and-comments-std.mdc create mode 100644 .cursor/rules/golang/golang-naming-std.mdc create mode 100644 .cursor/rules/golang/golang-use-getters.mdc create mode 100644 .cursor/rules/golang/grpcclient.mdc create mode 100644 .cursor/rules/observability/logging-best-practices.mdc create mode 100644 .cursor/rules/observability/metrics-best-practices.mdc create mode 100644 .cursor/rules/python/api-design.mdc create mode 100644 .cursor/rules/python/dependency-management.mdc create mode 100644 .cursor/rules/python/distributed-computing.mdc create mode 100644 .cursor/rules/python/fastapi-standards.mdc create mode 100644 .cursor/rules/python/infrastructure.mdc create mode 100644 .cursor/rules/python/microservices-architecture.mdc create mode 100644 .cursor/rules/python/python-coding-rules.mdc create mode 100644 .cursor/rules/python/testing-standards.mdc create mode 100644 .cursor/rules/rego/rego-coding-patterns.mdc create mode 100644 context/Base Account Pull Request Guidelines.md create mode 100644 context/Mini TDD - TIPS 4337 Bundler .docx diff --git a/.cursor/rules/bugsnag/fix-bugsnag-issues.mdc b/.cursor/rules/bugsnag/fix-bugsnag-issues.mdc new file mode 100644 index 00000000..630c982d --- /dev/null +++ b/.cursor/rules/bugsnag/fix-bugsnag-issues.mdc @@ -0,0 +1,72 @@ +--- +description: Describes how to handle a request to fix a bugsnag issue +globs: +alwaysApply: false +--- +# Bugsnag Ticket Workflow + +When a user provides a Bugsnag error URL or asks to fix a Bugsnag issue, follow this systematic approach: + +## 1. **Root Cause Analysis** + +### Error Investigation +- Use `mcp_bugsnag-mcp_list-error-events` to get recent events for the error +- Use `mcp_bugsnag-mcp_get-stacktrace` with `include_code: true` and `show_all_frames: true` to get the complete stacktrace +- Analyze the stacktrace to identify: + - The exact line and file where the error occurs + - The call stack that leads to the error + - The error message and context + +### Codebase Investigation +- Read the relevant files identified in the stacktrace +- Search for related code patterns or similar implementations +- Identify the data flow that leads to the problematic state +- Look for edge cases or missing null/undefined checks + +## 2. **Suggest Fixes (No Code Changes)** + +### Analysis Summary +- Provide a clear explanation of what's causing the error +- Identify the specific conditions that trigger the issue +- Explain the impact and severity of the error +- If you can't figure out what is going on, just say so and ask the user for more context + +### Proposed Solutions +- Present 1-3 potential fix approaches with pros/cons +- Suggest relevant tests to prevent regression +- Try to be tactical with your suggestions, avoid large refactors when possible + +### Implementation Recommendations +- Specify which files need to be modified +- Outline the exact changes needed (but don't make them yet) +- Mention any dependencies or related changes required +- Highlight potential breaking changes or compatibility concerns + +## 3. **User Confirmation & Implementation** + +### Get Approval +- Wait for user confirmation on the proposed approach +- Allow for discussion and refinement of the solution +- Clarify any ambiguous requirements or edge cases + +### Implementation & PR Creation +Once the user confirms the approach: +- Follow the below process: + - Making code changes + - Adding tests if needed + +--- + +**Example Workflow:** + +- User: "Fix this Bugsnag issue: https://app.bugsnag.com/" +- Assistant: + 1. Fetches error events and stacktrace from Bugsnag + 2. Analyzes the code to identify root cause + 3. Proposes specific fix approach with explanation + 4. Waits for user confirmation + 5. Making code changes and tests if needed + +--- + +**Note:** This workflow ensures thorough analysis before making changes, reducing the risk of incomplete fixes or introducing new issues while maintaining the systematic approach for PR creation. \ No newline at end of file diff --git a/.cursor/rules/coding-workflow.mdc b/.cursor/rules/coding-workflow.mdc new file mode 100644 index 00000000..a5b8a37a --- /dev/null +++ b/.cursor/rules/coding-workflow.mdc @@ -0,0 +1,19 @@ +--- +description: Coding workflow cursor must follow +globs: +alwaysApply: false +--- +# Coding workflow preferences +- Focus on the areas of code relevant to the task +- Do not touch code that is unrelated to the task +- Avoid making major changes to the patterns and architecture of how a feature works, after it has shown to work well, unless explicitly instructed +- Always think about what other methods and areas of code might be affected by code changes +- Keep code simple and readable +- Write thorough tests for all functionalities you wrote + +Follow this sequential workflow: +1. Write or update existing code +2. Write the incremental unit-test to cover code logic you wrote +3. Test unit-test pass +4. Verify it passes all the tests by running `make test` command +5. Ensue your unit-test has good code coverage for the code you have written diff --git a/.cursor/rules/github/pr-template-format.mdc b/.cursor/rules/github/pr-template-format.mdc new file mode 100644 index 00000000..bcdac6de --- /dev/null +++ b/.cursor/rules/github/pr-template-format.mdc @@ -0,0 +1,59 @@ +--- +description: +globs: +alwaysApply: false +--- +--- +description: Follow PR template format from .github/pull_request_template.md when creating pull request descriptions +globs: "**/*" +alwaysApply: false +--- + +# GitHub Pull Request Template Format + +When creating pull request descriptions, you **must** follow the format specified in `.github/pull_request_template.md` if it exists in the repository. + +## Rule Requirements + +1. **Check for Template**: Always check if `.github/pull_request_template.md` exists in the repository root before creating PR descriptions. + +2. **Use Template Structure**: If the template exists: + - Follow the exact section structure defined in the template + - Include all required sections from the template + - Maintain the same heading levels and formatting style + - Preserve any placeholder text guidelines or instructions + - Fill in the template sections with relevant information for the specific PR + +3. **Template Sections**: Common sections that should be preserved if present in the template include: + - **Summary/Description**: Brief overview of the changes + - **Changes Made**: Detailed list of modifications + - **Testing**: How the changes were tested + - **Type of Change**: Bug fix, feature, documentation, etc. + - **Checklist**: Action items or verification steps + - **Breaking Changes**: Any backward compatibility concerns + - **Related Issues**: Links to related issues or tickets + +4. **Fallback Behavior**: If no template exists, create a well-structured PR description with: + - Clear summary of changes + - Bullet points for key modifications + - Testing information if applicable + - Any relevant context or notes + +## Implementation Guidelines + +- **Read Template First**: Use tools to read the `.github/pull_request_template.md` file content before generating PR descriptions +- **Preserve Formatting**: Maintain markdown formatting, comments, and structure from the template +- **Fill Appropriately**: Replace template placeholders with actual, relevant information +- **Be Comprehensive**: Ensure all template sections are addressed, even if briefly +- **Stay Consistent**: Use the same tone and style as indicated by the template + +## Example Usage + +When creating a PR: +1. Check for `.github/pull_request_template.md` +2. If found, read the template content +3. Generate PR description following the template structure +4. Fill in each section with relevant information +5. Ensure all required sections are included + +This rule ensures consistency across all pull requests in repositories that have established PR templates, while providing a sensible fallback for repositories without templates. diff --git a/.cursor/rules/golang/coding-rules.mdc b/.cursor/rules/golang/coding-rules.mdc new file mode 100644 index 00000000..125cceb3 --- /dev/null +++ b/.cursor/rules/golang/coding-rules.mdc @@ -0,0 +1,27 @@ +--- +description: Rules to follow when writing code +globs: *.go +--- +You are Staff Software Engineer expert in Golang, Protobuff, GRPC. You write clean and properly docummented code. You ensure code written works, and you always write corresponding Unit-tests. +You are an expert in writing Unit-test, and specialised in updating existing unit-test to fit missing use-cases. + +# Coding pattern preferences +- Always prefer simple solutions. +- Keep the codebase very clean and organized. +- Avoid duplication of code whenever possible, which means checking for other areas of the codebase that might already have similar code and functionality. +- Write code that takes into account the different environments: development, staging, and production. +- You are careful to only make changes that are requested or you are confident are well understood and related to the change being requested. +- When fixing an issue or bug, do not introduce a new pattern or technology without first exhausting all options for the existing implementation. And if you finally do this, make sure to remove the old ipmlementation afterwards so we don't have duplicate logic. +- Avoid having files over 200-300 lines of code. Refactor at that point. +- Mocking data is only needed for tests, never mock data for dev or prod. +- Avoid writing scripts in files if possible, especially if the script is likely only to be run once. +- Never add stubbing or fake data patterns to code that affects the dev or prod environments. +- Never overwrite config *.yml (Yaml) files without first asking and confirming. +- It is acceptable to say you do not know. +- Do not write your own mocks in testing. Follow this sequence: +1. Update Makefile to generate the mock needed. + Following the example for internal packages + `mockgen -source=internal/client/users_service.go -destination=internal/dao/mocks/mock_users_service.go -package=mockdao` + and for external packages follow this: + ` mockgen -destination=mocks/eth_client_mock.go -mock_names EthClient=MockEthClient -package=mocks github.cbhq.net/intl/rip7755-fulfiller/internal/client EthClientmockgen` +2. Update testing code to use the generated mock diff --git a/.cursor/rules/golang/english-and-comments-std.mdc b/.cursor/rules/golang/english-and-comments-std.mdc new file mode 100644 index 00000000..c35cf56f --- /dev/null +++ b/.cursor/rules/golang/english-and-comments-std.mdc @@ -0,0 +1,49 @@ +--- +description: Make sure to always add clear comments within the codebase +globs: *.go +alwaysApply: true +--- +# Standard: Language, Comments, and Documentation + +This rule defines the standards for language use and commenting within the codebase, prioritizing clarity and developer experience for engineers familiar with the project. + +**1. Language:** + +* **All** code artifacts, including variable names, function names, comments, documentation, commit messages, and generated rules, **must** be written in **simple, clear, friendly and idiomatic English**. + +**2. Comments:** + +* **Target Audience:** Assume the reader is an experienced developer familiar with Go and the general project context. +* **Prioritize Readability:** Code should be self-documenting whenever possible through clear naming and structure. +* **Avoid Redundant Comments:** Do **not** add comments that merely restate what the code clearly does. For example: + ```go + // Bad: Comment explains the obvious + // Increment count + count++ + + // Good: Comment starts with the function name + // GetUserByID finds a user by their ID + func GetUserByID(id string) (*User, error) { ... } + ``` +* **Focus on the "Why", Not Just the "What":** Prioritize comments that explain *why* a particular approach was taken, especially if it's non-obvious, involves trade-offs, or relates to external factors or historical context. + * Explain complex logic or algorithms briefly. + * Clarify the purpose of seemingly arbitrary values or constants. + * Document known limitations, potential issues, or future work (`TODO`, `FIXME`). + * Add comments when fixing subtle bugs to explain the reasoning. + ```go + // Good: Explains the rationale for a non-obvious choice + // Use FNV-1a hash for Redis hash tags to optimize for speed and key length, + // as cryptographic security is not required for slot assignment. + func hashUserIDForTag(userID string) string { ... } + + // Good: Explains a workaround or limitation + // TODO(GH-123): Refactor this when the upstream API supports batch requests. + for _, item := range items { ... } + ``` +* **Placement:** Place comments on the line *before* the code they refer to, or sometimes at the end of a line for very short clarifications. + +**3. Documentation (e.g., READMEs, Design Docs):** + +* Maintain clarity and conciseness. +* Keep documentation up-to-date with significant code changes. +* Use diagrams or examples where appropriate to illustrate complex concepts. diff --git a/.cursor/rules/golang/golang-naming-std.mdc b/.cursor/rules/golang/golang-naming-std.mdc new file mode 100644 index 00000000..25a1e963 --- /dev/null +++ b/.cursor/rules/golang/golang-naming-std.mdc @@ -0,0 +1,69 @@ +--- +description: Avoid package prefix redundancy when naming +globs: *.go +alwaysApply: false +--- +# Go Standard: Naming Conventions - Avoid Package Prefix Redundancy + +This rule outlines the standard Go practice for naming exported identifiers to avoid redundancy with the package name. + +**The Standard:** + +When naming exported identifiers (types, functions, variables, constants), **avoid repeating the package name** if the context provided by the package itself makes the identifier clear. + +**Rationale:** + +* **Readability:** Code that imports the package becomes cleaner and less verbose. For example, `store.New()` is more idiomatic and readable than `store.NewStore()`. +* **Conciseness:** Reduces unnecessary stuttering in code (e.g., `store.StoreType` vs. `store.Type`). +* **Idiomatic Go:** Follows the common practice seen in the Go standard library and many popular Go projects. + +**Examples:** + +```go +// --- Package: store --- + +// BAD: Repeats "store" +package store + +type StoreConfig struct { ... } +func NewStore(cfg StoreConfig) (*Store, error) { ... } +var DefaultStoreOptions StoreOptions + +// GOOD: Avoids repeating "store" +package store + +type Config struct { ... } // Type name is clear within package 'store' +func New(cfg Config) (*Store, error) { ... } // Function name 'New' is clear +var DefaultOptions Options // Variable name is clear + +type Store struct { ... } // OK: Identifier itself IS the package name conceptually +``` + +When importing and using the "good" example: + +```go +import "path/to/store" + +// ... +cfg := store.Config{ ... } +activityStore, err := store.New(cfg) +opts := store.DefaultOptions +var s store.Store +``` + +This reads much better than: + +```go +import "path/to/store" + +// ... +cfg := store.StoreConfig{ ... } +activityStore, err := store.NewStore(cfg) +opts := store.DefaultStoreOptions +var s store.Store +``` + +**Exceptions:** + +* It is acceptable if the identifier itself essentially *is* the package name (e.g., `package http; type Client`, `package store; type Store`). +* Sometimes repeating a part of the package name is necessary for clarity if the package has many distinct concepts. diff --git a/.cursor/rules/golang/golang-use-getters.mdc b/.cursor/rules/golang/golang-use-getters.mdc new file mode 100644 index 00000000..149f3802 --- /dev/null +++ b/.cursor/rules/golang/golang-use-getters.mdc @@ -0,0 +1,53 @@ +--- +description: Prefer getter methods over direct field access +globs: *.go +alwaysApply: false +--- +# Go Standard: Prefer Getter Methods (Especially for Protobuf) + +This rule encourages the use of getter methods over direct field access, particularly when working with structs generated from Protobuf definitions. + +**The Standard:** + +**Prefer using generated getter methods (e.g., `myProto.GetMyField()`) over direct field access (e.g., `myProto.MyField`) when such getters are available.** This is especially relevant for structs generated by the Protobuf compiler (`protoc-gen-go`). + +**Rationale:** + +* **Encapsulation and Nil Safety:** Getters often provide a layer of abstraction. For Protobuf messages, getters automatically handle `nil` checks for pointer fields (like optional message fields or fields within a `oneof`), returning a zero value instead of causing a panic. This significantly improves robustness. +* **Consistency:** Using getters consistently makes the code easier to read and maintain, aligning with common Go practices for Protobuf. +* **Future-Proofing:** Relying on the getter method decouples the calling code from the exact internal representation of the field. If the underlying field changes in a backward-compatible way (e.g., how a default value is handled), code using the getter is less likely to break. +* **Helper Logic:** Getters might potentially include minor logic (though less common in basic Protobuf getters beyond nil checks). + +**Example (Protobuf):** + +```protobuf +// -- Example.proto -- +message UserProfile { + optional string name = 1; + optional int32 age = 2; +} +``` + +```go +// -- Go code -- +import "path/to/gen/go/examplepb" + +func processProfile(profile *examplepb.UserProfile) { + // GOOD: Uses getter, safe even if profile or profile.Name is nil. + name := profile.GetName() + age := profile.GetAge() // Also handles potential nil receiver safely. + + // BAD: Direct access risks nil pointer dereference if profile is non-nil + // but profile.Name is nil (for optional fields). + // nameDirect := *profile.Name // PANICS if profile.Name is nil! + // ageDirect := *profile.Age // PANICS if profile.Age is nil! + + fmt.Printf("Name: %s, Age: %d\n", name, age) +} +``` + +**Exceptions:** + +* **No Getter Available:** If a struct field does not have a corresponding getter method, direct access is necessary. +* **Performance Critical Code:** In extremely rare, performance-critical sections where profiling has demonstrably shown the function call overhead of the getter to be a bottleneck, direct access *might* be considered cautiously. This should be well-documented and justified. +* **Setting Values:** This rule applies to *reading* values. Setting struct fields typically involves direct assignment. diff --git a/.cursor/rules/golang/grpcclient.mdc b/.cursor/rules/golang/grpcclient.mdc new file mode 100644 index 00000000..5dac8a63 --- /dev/null +++ b/.cursor/rules/golang/grpcclient.mdc @@ -0,0 +1,17 @@ +--- +description: Creating a new grpc connection should use csf's grpcclient, not golang/grpc +globs: *.go +alwaysApply: false +--- +Pull in the package from github.cbhq.net/engineering/csf/grpcclient + +Here is an example of how you should implement it +``` + manager := csf.New() + ctx := manager.ServiceContext() + conn, err := grpcclient.Dial( + ctx, + endpoint, + grpcclient.WithDialOpt(grpc.WithBlock()), + ) +``` \ No newline at end of file diff --git a/.cursor/rules/observability/logging-best-practices.mdc b/.cursor/rules/observability/logging-best-practices.mdc new file mode 100644 index 00000000..52e94b5a --- /dev/null +++ b/.cursor/rules/observability/logging-best-practices.mdc @@ -0,0 +1,255 @@ +--- +description: Rules to follow when logging +globs: ["*.go", "*.py"] +--- +## Rule +Ensure all logging statements are correct, useful, performant, and secure. Logs must accurately reflect the code's logic, provide sufficient context for debugging, avoid performance degradation, and never expose sensitive information. Use appropriate log levels and avoid logging sensitive data, large objects, or high-frequency debug information. + +Refer to [logging best practices](https://docs.cbhq.net/infra/observability/logging) for more details. + +## Scope +This rule ONLY APPLIES when ALL the following conditions are met: +1. Code contains logging statements (logger.debug, log.info, console.log, etc.) +2. The logging exhibits one or more of these problematic patterns (tagged with Defect Patterns and scenarios): + - **(SS-1) Logging Sensitive Data:** Exposing credentials, tokens, PII, or financial data (passwords, API keys, email addresses). + - **(SS-2) Logging Unsanitized Objects:** Logging entire request/response bodies or complex objects without removing sensitive fields. + - **(PF-1) Logging in High-Frequency Loops:** Placing log statements inside tight loops or on other hot paths like function entry/exit logging for every function, causing excessive volume. + - **(LV-1) Improper Log Level:** Using `DEBUG` or `TRACE` in non-development environments. Using `WARN` or `ERROR` for informational messages. + - **(SM-1) Unit/Metric Mismatch:** The unit in the log message (e.g., "ms") does not match the variable's actual unit (e.g., nanoseconds). + - **(SM-2) Message Contradicts Logic:** The log message misrepresents the code's state (e.g., logging "Success" in an `if err!= nil` block). + - **(IS-1) Insufficient Context:** An error log is not actionable because it omits the `error` variable or critical identifiers (e.g., `transaction_id`). + - **(VR-2) Placeholder-Argument Mismatch:** The number of placeholders in a format string (e.g., `%s`) does not match the number of provided variables. + - **(RD-3) Vague or Ambiguous Message:** The log message is too generic to be useful (e.g., "Done", "Error"). + +| Defect Patterns | Scenario Name | +| --- | --- | +| **RD:** Readability Issues | RD-1: Complicated domain-specific terminology
RD-2: Non-standard language used
RD-3: Poorly formatted or unclear messages | +| **VR:** Variable Issues | VR-1: Incorrect variable value logging
VR-2: Placeholder–value mismatch | +| **LV:** Logging Level Issues | LV-1: Improper verbosity level | +| **SM:** Semantics Inconsistent | SM-1: Wrong unit or metric label
SM-2: Message text does not match the code
SM-3: Misused variables in the message | +| **SS:** Sensitive Information | SS-1: Credentials logged in plain text
SS-2: Dumping whole objects without scrubbing | +| **IS:** Insufficient Information | IS-1: Insufficient information | +| **PF:** Performance Issues | PF-1: Logging on hot path
PF-2: Costly string operations | + +## Out of Scope +This rule does NOT apply to: +- ERROR and WARN level logs for genuine issues +- INFO level logs for significant business events +- Structured logging that includes only relevant, non-sensitive fields. +- Logs that are properly sampled or rate-limited +- Test files or development-only code +- Logs that are conditionally enabled for debugging + +## Good Examples + +1. Appropriate log levels with structured data: +```go +logger.Info("User login successful", + "user_id", userID, + "login_method", "oauth", + "ip_address", clientIP, +) +``` + +2. ERROR logs with context but no sensitive data: +```go +logger.Error("Payment processing failed", + "error_code", "INSUFFICIENT_FUNDS", + "transaction_id", txnID, + "user_id", userID, + "retry_count", retryCount, +) +``` +```go +user, err := db.FindUser(userID) +if err!= nil { + logger.Error("Failed to find user", + "error", err, + "user_id", userID, + "trace_id", traceID, + ) + return +} +``` + + +3. Conditional debug logging: +```go +if config.DebugEnabled { + logger.Debug("Processing order for user", "user_id", userID) +} +``` + +4. Sampling high-frequency events: +```go +// Only log 1% of successful requests +if rand.Float32() < 0.01 { + logger.Info("Request processed successfully", + "endpoint", endpoint, + "duration_ms", duration.Milliseconds(), + ) +} +``` + +5. Structured logging with relevant fields: +```go +logger.Info("Order processed", + "order_id", order.ID, + "user_tier", user.Tier, + "payment_method", "card", + "processing_time_ms", processingTime, +) +``` + +6. Summarizing after a loop instead of logging within it: +```go +processedCount := 0 +for _, item := range items { + if err := process(item); err == nil { + processedCount++ + } +} +logger.Info("Batch processing complete", + "total_items", len(items), + "processed_count", processedCount, +) +``` + +7. Logging specific, safe fields instead of a whole object: +```go +logger.Info("User profile updated", + "user_id", user.ID, + "user_tier", user.Tier, + "updated_fields", updatedFields, +) +``` + +8. Ensuring unit consistency in logs +```go +//... operation... +duration := time.Since(startTime) +logger.Info("Request processed", + "duration_ms", duration.Milliseconds(), +) +``` + +## Bad Examples + +1. (LV-1) DEBUG logging in production code: +```go +// DEBUG logs create excessive volume +logger.Debug("Entering function processPayment") +logger.Debug("Validating payment request") +logger.Debug("Connecting to payment gateway") +logger.Debug("Exiting function processPayment") +``` + +2. (PF-1) Logging inside loops: +```go +// Creates massive log volume +for _, item := range items { + logger.Info("Processing item", "item_id", item.ID) + // ... process item +} +``` + +3. (SS-2) Logging entire objects or request bodies: +```go +// Logs potentially sensitive data and large objects +logger.Info("Received request", "request_body", fmt.Sprintf("%+v", requestBody)) +logger.Info("User object", "user", fmt.Sprintf("%+v", user)) +``` +```go +// BAD: Logs the entire user object, potentially exposing PII. +logger.Info("User object details", "user", fmt.Sprintf("%+v", user)) +``` + +4. (SS-1) Logging sensitive information: +```go +// Exposes sensitive data in logs +logger.Info("Authentication attempt", + "email", user.Email, + "password", password, + "api_key", apiKey, + "token", authToken, + "auth_token", authToken, + "bearer_token", bearerToken, + "credit_card", creditCard, +) +``` + +5. (PF-1) Function entry/exit logging everywhere: +```go +// Excessive noise for every function +func calculateTotal(items []Item) float64 { + logger.Debug("Entering calculateTotal") + total := 0.0 + for _, item := range items { + total += item.Price + } + logger.Debug("Exiting calculateTotal", "total", total) + return total +} +``` + +6. (SS-1) Logging URLs with sensitive information: +```go +// Exposes sensitive token in URL parameter +logger.Info("API request", "url", fmt.Sprintf("/api/users/%s/payments/%s?token=%s", userID, paymentID, token)) +``` + +7. (SM-2) Message contradicts code logic: +```go +// BAD: A success message is logged in the error-handling block. +err := processPayment(paymentDetails) +if err!= nil { + logger.Info("Payment processed successfully", "transaction_id", paymentDetails.ID) + //... handle error... +} +``` + +8. (IS-1) Insufficient context in an error log: +```go +// BAD: The log is not actionable because it omits the actual 'err' variable. +err := db.Save(user) +if err!= nil { + logger.Error("Failed to save user to database", "user_id", user.ID) +} +``` + +9. (SM-1) Unit mismatch in the log message: +```go +// BAD: The log text claims "ms" but the variable is in nanoseconds. +startTime := time.Now() +//... operation... +durationNanos := time.Since(startTime).Nanoseconds() +logger.Info(fmt.Sprintf("Task completed in %d ms", durationNanos)) +``` + +10. (VR-2) Placeholder-argument mismatch: +```go +// BAD: Two placeholders but only one argument provided. +logger.Error(fmt.Sprintf("Login for user %s from %s failed", userID)) +``` + + +## Evaluation Process +1. Identify all logging statements in the code +2. Check log levels - flag DEBUG logs that aren't conditionally enabled +3. Analyze control flow - for each logging statement, analyze its surrounding code to understand the logical context (e.g., is it inside an error-handling block like if err!= nil, a success path, or a loop?). Look for logging patterns inside loops or high-frequency operations +4. Extract semantic intent - use natural language understanding to determine the meaning of the static log message text (e.g., does it imply success, failure, or a status update?). +5. Correlate Logic and Intent - Compare the code's logical context with the message's semantic intent. Flag contradictions (e.g., a "success" message in a failure block - SM-2). +6. Analyze Log Content and Variables: + - Flag the logging of entire un-sanitized objects, request bodies, or other large data structures (SS-2). + - Scan for sensitive data patterns (passwords, keys, PII) in variable names, message text, and URL parameters (SS-1). + - URLs with parameters that might contain sensitive data + - For metric variables (e.g., duration), verify consistency between the variable's actual unit and the unit stated in the log message (SM-1). + - In error-handling blocks, verify that the `error` variable itself is being logged to prevent IS-1. + - Check for function entry/exit logging patterns +7. For each problematic pattern, suggest alternatives: + - Use appropriate log levels (ERROR, WARN, INFO) + - Sample high-frequency logs + - Log only relevant fields instead of entire objects + - Use structured logging with sanitized data + - Move detailed debugging to distributed tracing + - Rate-limit repetitive logs diff --git a/.cursor/rules/observability/metrics-best-practices.mdc b/.cursor/rules/observability/metrics-best-practices.mdc new file mode 100644 index 00000000..d2230570 --- /dev/null +++ b/.cursor/rules/observability/metrics-best-practices.mdc @@ -0,0 +1,136 @@ +--- +description: Rules to follow when emitting metrics +globs: ["*.go", "*.py"] +--- +## Rule +Do not use high-cardinality values as tags when emitting metrics. High-cardinality tags can significantly increase observability costs and impact system performance. Every tag that contains an ID must be flagged. + +Refer to [tagging strategy](https://docs.cbhq.net/infra/observability/metrics#tagging-strategy) for more details. + +## Scope +This rule applies to ANY metric emission found ANYWHERE in the code changes, regardless of the primary purpose of the PR. ALL metric emission calls (statsd) must be checked for violations. + +Violation happens when ALL the following conditions are met: +1. Code is emitting metrics to a monitoring system (Datadog, StatsD, etc.) +2. Tags or labels are being added to the metric +3. The tag values contain AT LEAST ONE high-cardinality. + +### High-cardinality Guidelines: +A tag value is considered high-cardinality if it falls into any of these categories: +- **Looks unique** – anything that sounds like it will generate a one-off value (e.g., id, uuid, token, session, generated_x) +- **Continuous values** – non-discrete numbers that can vary infinitely, like current_price, latitude, longitude, sensor readings, etc. +- **High entropy values** – anything random or cryptographic such as random, hash, sha1, md5, encrypted, signature + +### Common High-cardinality Examples: +- **Identifiers**: User IDs, customer IDs, account identifiers (`user_id`, `customer_id`, `account_id`) +- **Request tracking**: Request IDs, trace IDs, transaction IDs (`message_id`, `request_id`, `trace_id`) +- **Pattern-based keys**: Any tag key ending with `_id`, `_uuid`, `_token` +- **Time-based values**: Timestamps or time-based values +- **Network data**: URLs with parameters, dynamic paths, IP addresses, specific hostnames +- **Unique identifiers**: UUIDs, hashes, or other unique identifiers +- **Personal data**: Email addresses or user-specific data + +## Good Examples + +1. Using low-cardinality status codes: +```go +statsdClient.CountWithTags("api.requests_total", 1, map[string]string{ + "method": "GET", + "status": "200", + "endpoint": "/api/users", +}) +``` + +2. Building tags separately with low-cardinality values: +```go +tags := map[string]string{ + "method": "GET", + "status": "200", + "endpoint": "/api/users", +} +statsdClient.CountWithTags("api.requests_total", 1, tags) +``` + +3. Using bounded categorical values: +```go +statsdClient.CountWithTags("payment.processed", 1, map[string]string{ + "payment_method": "card", // Limited values: card, bank, crypto + "region": "us-east-1", // Limited AWS regions + "user_tier": "premium", // Limited tiers: basic, premium, enterprise +}) +``` + +4. Aggregating instead of individual IDs: +```go +// Instead of user_id tag, use aggregated user tier +statsdClient.GaugeWithTags("user.active_sessions", sessionCount, map[string]string{ + "user_tier": getUserTier(userID), // Low cardinality + "region": "us-west-2", +}) +``` + +## Bad Examples + +1. Using user IDs or message IDs as tags: +```go +// VIOLATION: user_id and message_id are high-cardinality IDs +statsd.IncrWithTags(statsdUSTEventProcessingFailure, map[string]string{ + "message_id": messageID, // VIOLATION: message_id is high-cardinality + "error_type": "nil_body", +}) +``` + +2. Building tags separately with ID values: +```go +// VIOLATION: Still problematic when tags are built separately +tags := map[string]string{ + "user_id": userID, // VIOLATION: user_id is high-cardinality + "message_id": messageID, // VIOLATION: message_id is high-cardinality +} +statsd.HistogramWithTags(statsdUSTRepositoryOperationTime, value, tags) +``` + +3. Using request IDs or trace IDs: +```go +// VIOLATION: Request IDs are unique for every request +statsdClient.TimingWithTags("api.response_time", duration, map[string]string{ + "request_id": "req_abc123def456", // VIOLATION: request_id is high-cardinality + "trace_id": "7d5d747be160e280504c099d984bcfe0", // VIOLATION: trace_id is high-cardinality +}) +``` + +4. Using timestamps as tags: +```go +// VIOLATION: Timestamps create unlimited unique values +stats.CountWithTags("queue.length", 1, map[string]string{ + "timestamp": time.Now().Format("2006-01-02T15:04:05"), // VIOLATION: timestamp is high-cardinality + "queue_name": "payments", +}) +``` + +5. Using IP addresses: +```go +// VIOLATION: IP addresses have very high cardinality +statsd.GaugeWithTags("connections.active", 1, map[string]string{ + "client_ip": "192.168.1.100", // VIOLATION: IP address is high-cardinality + "hostname": "server-abc123-def456", // VIOLATION: Dynamic hostnames are high-cardinality +}) +``` + +## Evaluation Process +1. Search the entire code change for ANY calls to `statsd` function that ends with `WithTags` (`statsd.*WithTags`) or tags map building, regardless of the PR's stated purpose +2. For each metric emission found, examine ALL tag keys in the map +3. If ANY tag key contains high-cardinality patterns, flag as violation. Examples for violations: + - `user_id`, `message_id`, `request_id`, `trace_id`, `session_id`, `customer_id` + - Any key ending with `_id`, `_uuid`, `_token` + - Timestamps, IP addresses, URLs with parameters +4. Do not skip metric calls because they seem unrelated to the main PR purpose +5. Check ANY function that contains these strings in its name: `CountWithTags`, `IncrWithTags`, `GaugeWithTags`, `HistogramWithTags`, `TimingWithTags`, `DistributionWithTags`. This includes methods from any package or client (e.g., `statsd.CountWithTags()`, `client.IncrWithTags()`, `metrics.GaugeWithTags()`, etc.) + +**Example**: Even if a PR is titled "Add configuration options", still check ALL metric emissions like: +```go +statsd.IncrWithTags(metric, map[string]string{ + "message_id": messageID, // VIOLATION - Must be flagged + "error_type": "nil_body", +}) +``` diff --git a/.cursor/rules/python/api-design.mdc b/.cursor/rules/python/api-design.mdc new file mode 100644 index 00000000..58f975f1 --- /dev/null +++ b/.cursor/rules/python/api-design.mdc @@ -0,0 +1,28 @@ +# .cursor/rules/python/api-design.mdc +--- +description: API design principles for Python microservices +globs: ["*.py"] +alwaysApply: true +--- +# API Design Principles + +## REST API Design +- Use proper HTTP methods (GET, POST, PUT, DELETE) +- Implement proper status codes +- Use plural nouns for resource endpoints +- Version APIs in the URL (e.g., /v1/resources) +- Use query parameters for filtering and pagination + +## Request/Response +- Validate all input data +- Use Pydantic models for request/response schemas +- Include proper error responses +- Implement pagination for list endpoints +- Use consistent response formats + +## Security +- Implement proper authentication +- Use JWT for stateless authentication +- Implement rate limiting +- Validate and sanitize all inputs +- Use HTTPS only \ No newline at end of file diff --git a/.cursor/rules/python/dependency-management.mdc b/.cursor/rules/python/dependency-management.mdc new file mode 100644 index 00000000..a02d227f --- /dev/null +++ b/.cursor/rules/python/dependency-management.mdc @@ -0,0 +1,21 @@ +# .cursor/rules/python/dependency-management.mdc +--- +description: Package and dependency management guidelines +globs: ["pyproject.toml", "requirements.txt", "setup.py"] +alwaysApply: true +--- +# Dependency Management + +## Package Management +- Use Poetry for dependency management +- Pin all dependencies with exact versions +- Use separate dependency groups for dev and prod +- Regular security audits with safety +- Keep dependencies up to date + +## Virtual Environments +- Use virtual environments for all projects +- Document Python version requirements +- Use .env files for environment variables +- Keep production dependencies minimal +- Document all third-party integrations \ No newline at end of file diff --git a/.cursor/rules/python/distributed-computing.mdc b/.cursor/rules/python/distributed-computing.mdc new file mode 100644 index 00000000..0b727edd --- /dev/null +++ b/.cursor/rules/python/distributed-computing.mdc @@ -0,0 +1,25 @@ +# .cursor/rules/python/distributed-computing.mdc +--- +description: Guidelines for distributed computing with Ray +globs: ["*.py"] +alwaysApply: true +--- +# Distributed Computing Standards + +## Ray Framework Usage +- Use Ray for distributed task processing +- Implement proper actor patterns +- Use Ray's object store effectively +- Handle distributed errors properly + +## Scaling Patterns +- Implement proper auto-scaling +- Use resource management effectively +- Handle node failures gracefully +- Implement proper checkpointing + +## Performance +- Use Ray's performance monitoring +- Implement proper batching +- Use Ray's memory management +- Profile distributed operations \ No newline at end of file diff --git a/.cursor/rules/python/fastapi-standards.mdc b/.cursor/rules/python/fastapi-standards.mdc new file mode 100644 index 00000000..a83a666f --- /dev/null +++ b/.cursor/rules/python/fastapi-standards.mdc @@ -0,0 +1,41 @@ +# .cursor/rules/python/fastapi-standards.mdc +--- +description: FastAPI-specific development standards and patterns +globs: ["*.py"] +alwaysApply: true +--- +# FastAPI Development Standards + +## Project Structure +- Use the following directory structure: + ``` + app/ + ├── api/ + │ └── v1/ + │ └── endpoints/ + ├── core/ + │ ├── config.py + │ └── security.py + ├── models/ + ├── schemas/ + └── services/ + ``` + +## FastAPI Best Practices +- Use dependency injection for service dependencies +- Implement proper exception handlers +- Use background tasks for async operations +- Implement proper middleware chain +- Use FastAPI's built-in OpenAPI support + +## Performance Optimization +- Use async/await properly +- Implement caching strategies +- Use connection pooling for databases +- Implement proper background tasks + +## Security +- Use FastAPI's security dependencies +- Implement proper CORS policies +- Use rate limiting +- Implement proper authentication middleware \ No newline at end of file diff --git a/.cursor/rules/python/infrastructure.mdc b/.cursor/rules/python/infrastructure.mdc new file mode 100644 index 00000000..d9bd974d --- /dev/null +++ b/.cursor/rules/python/infrastructure.mdc @@ -0,0 +1,25 @@ +# .cursor/rules/python/infrastructure.mdc +--- +description: Infrastructure and deployment standards +globs: ["*.py", "Dockerfile", "*.yaml"] +alwaysApply: true +--- +# Infrastructure Standards + +## Containerization +- Use multi-stage Docker builds +- Implement proper health checks +- Use non-root users +- Follow container security best practices + +## Kubernetes +- Use proper resource requests/limits +- Implement proper probes +- Use proper service mesh integration +- Follow GitOps practices + +## CI/CD +- Implement proper testing stages +- Use proper security scanning +- Implement proper deployment strategies +- Use proper environment separation \ No newline at end of file diff --git a/.cursor/rules/python/microservices-architecture.mdc b/.cursor/rules/python/microservices-architecture.mdc new file mode 100644 index 00000000..e4352957 --- /dev/null +++ b/.cursor/rules/python/microservices-architecture.mdc @@ -0,0 +1,36 @@ +# .cursor/rules/python/microservices-architecture.mdc +--- +description: Guidelines for Python microservice architecture +globs: ["*.py"] +alwaysApply: true +--- +# Microservice Architecture Guidelines + +## Service Design +- Keep services small and focused on a single business capability +- Use FastAPI for HTTP APIs +- Use gRPC for internal service communication +- Implement health check endpoints +- Use OpenAPI/Swagger for API documentation +- Use proper service discovery +- Implement proper circuit breaking +- Use proper message queuing +- Implement proper retry policies + +## Configuration +- Use environment variables for service configuration +- Store secrets in a secure vault (e.g., HashiCorp Vault) +- Use configuration management for different environments +- Implement feature flags for gradual rollouts + +## Observability +- Implement structured logging using `structlog` +- Use OpenTelemetry for distributed tracing +- Implement metrics using Prometheus +- Set up proper monitoring dashboards + +## Resilience +- Implement circuit breakers for external calls +- Use retries with exponential backoff +- Implement rate limiting +- Handle partial failures gracefully \ No newline at end of file diff --git a/.cursor/rules/python/python-coding-rules.mdc b/.cursor/rules/python/python-coding-rules.mdc new file mode 100644 index 00000000..34e99a74 --- /dev/null +++ b/.cursor/rules/python/python-coding-rules.mdc @@ -0,0 +1,32 @@ +# .cursor/rules/python/python-coding-rules.mdc +--- +description: Python coding standards and best practices +globs: ["*.py"] +alwaysApply: true +--- +# Python Coding Standards + +## Code Style +- Follow PEP 8 style guide +- Use type hints for all function parameters and return values +- Maximum line length: 88 characters (Black formatter standard) +- Use descriptive variable names that reflect their purpose +- Use docstrings for all public modules, functions, classes, and methods + +## Project Structure +- Use src-layout pattern for all Python packages +- Separate business logic from API handlers +- Keep modules focused and single-responsibility +- Use absolute imports over relative imports + +## Error Handling +- Use custom exceptions for domain-specific errors +- Always include meaningful error messages +- Handle exceptions at appropriate levels +- Log errors with proper context + +## Best Practices +- Use dataclasses or Pydantic models for data structures +- Implement proper logging with structured data +- Use environment variables for configuration +- Follow the principle of least privilege \ No newline at end of file diff --git a/.cursor/rules/python/testing-standards.mdc b/.cursor/rules/python/testing-standards.mdc new file mode 100644 index 00000000..84638166 --- /dev/null +++ b/.cursor/rules/python/testing-standards.mdc @@ -0,0 +1,28 @@ +# .cursor/rules/python/testing-standards.mdc +--- +description: Testing requirements for Python microservices +globs: ["*_test.py", "test_*.py"] +alwaysApply: true +--- +# Testing Standards + +## Unit Tests +- Use pytest as the testing framework +- Maintain minimum 80% code coverage +- Mock external dependencies +- Use fixtures for test data +- Test both success and error cases + +## Integration Tests +- Test service integrations +- Use docker-compose for local testing +- Implement API tests using pytest-asyncio +- Test database interactions +- Verify message queue operations + +## Performance Tests +- Implement load tests using locust +- Test service scalability +- Measure response times +- Test rate limiting +- Verify resource usage \ No newline at end of file diff --git a/.cursor/rules/rego/rego-coding-patterns.mdc b/.cursor/rules/rego/rego-coding-patterns.mdc new file mode 100644 index 00000000..06695508 --- /dev/null +++ b/.cursor/rules/rego/rego-coding-patterns.mdc @@ -0,0 +1,94 @@ +--- +description: +globs: *.rego +alwaysApply: false +--- +# Common Rego Patterns and Idioms + +## Data Access Patterns +```rego +# Safe object access +value := object.get("key", "default") + +# Array iteration +result := [item | item := array[_]] + +# Set operations +combined := set_union(set1, set2) +``` + +## Control Flow +```rego +# Conditional logic +allow { + condition1 + condition2 +} else { + condition3 +} + +# Early returns +deny["reason"] { + not is_valid +} + +# Multiple conditions +allow { + count(violations) == 0 + is_authorized +} +``` + +## Common Functions +```rego +# Existence check +exists { + count(array) > 0 +} + +# Contains check +contains { + array[_] == value +} + +# All elements satisfy condition +all_valid { + count([x | x := array[_]; not is_valid(x)]) == 0 +} +``` + +## Testing Patterns +```rego +# Test case structure +test_allow_when_valid { + allow with input as {"valid": true} +} + +# Test helper functions +test_is_valid { + is_valid with input as {"value": "test"} +} +``` + +## Error Handling +```rego +# Error collection +errors[msg] { + not is_valid + msg := "Invalid input" +} + +# Multiple error messages +errors[msg] { + not is_authorized + msg := "Not authorized" +} +``` + +## Best Practices +1. Use helper functions for complex logic +2. Keep rules focused and single-purpose +3. Use meaningful variable names +4. Document complex logic with comments +5. Use consistent formatting +6. Break down complex conditions into smaller rules diff --git a/context/Base Account Pull Request Guidelines.md b/context/Base Account Pull Request Guidelines.md new file mode 100644 index 00000000..2f9e6e99 --- /dev/null +++ b/context/Base Account Pull Request Guidelines.md @@ -0,0 +1,172 @@ +# Base Account Pull Request Guidelines + +Status **Living** +Updated Jun 16, 2025 +Created Oct 20, 2024 + +[Overview](#overview) + +[Why](#why) + +[SLA](#sla) + +[Success Metrics](#success-metrics) + +[Guidelines](#guidelines) + +[Authoring](#authoring) + +[Reviewing](#reviewing) + +[Owning a Codebase](#owning-a-codebase) + +[Appendix](#appendix) + +[FAQ](#faq) + +[Resources](#resources) + +[Notes](#notes) + +# Overview {#overview} + +*“Honesty in small things is not a small thing.”* + +- *Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship* + +PRs are the lifeline of the team. It’s what allows us to ship value, decides our future in terms of maintenance cost, and has a high impact on our daily QOL. When code is well-maintained and untangled, velocity is sustained. + +This document lays out SLAs, guidelines, and how we think about pull requests as a world-class engineering team. + +## Why {#why} + +Having a quality pull request process allows us to build with sustained velocity and deliver improvements and features to our users. + +Pull requests allow us to: + +* **Hold and improve the bar on quality:** we can catch bugs and architectural code smells early, before these have reached QA or users +* **Build a championship team and mentor top talent**: by knowledge-sharing through clear descriptions and deep, thoughtful reviews, this will help our team become stronger +* **Stay customer focused with repeatable innovation:** by keeping the PRs tight and decoupled, this will allow us to consistently ship (or roll back) incremental improvements to our customers +* **Encourage ownership:** by having clear ownership around domains, this will motivate authors and reviewers to hold the quality high, allowing for the codebase to be malleable to fit the business needs while reducing incidents and bugs + +As engineers, pull requests are a key part of our day-to-day life, whether it’s authoring or reviewing them. By holding a high bar, it will also improve our daily quality of life. + +## SLA {#sla} + +| Name | SLA | Why | +| :---- | :---- | :---- | +| **PR Review** | Reviewed within half a working day | Pull requests are encouraged to be reviewed within half a working day. If they take longer than 1 working day, likely, something needs to be improved. | + +## Success Metrics {#success-metrics} + +| Metric | Why | +| :---- | :---- | +| **Time to PR Review** | Getting a review quickly and swiftly is one of the fastest ways to get unblocked. By having fast reviews, it powers the flywheel of shared context → quality code → maintainable codebase → iteration. | +| **Time from PR Open to Production** | Getting code merged is one thing. Getting it deployed is how it gets in front of customers. | +| **\# of Incidents** | By having a quality author and review process, errors should be caught during the pull request process. | +| **\# of QA regression bugs** | By having a quality author and review process, errors should be caught during the pull request process. | + +# Guidelines {#guidelines} + +## Authoring {#authoring} + +* **PRs should be tight.** This allows for teammates to review deeply and thoroughly. PRs should either make deep changes (creating two new functions) or a shallow change across a breadth of files (renaming a function). + + * PRs should be \<500 LOC. This is a guideline. There may be PRs which may be higher LOC (eg: if it’s auto-generated, boilerplate, or scaffolding). There also may be PRs which are 1-2 lines. + + * PRs should touch \<10 files. This is a guideline. If the PR is focused on renaming across a codebase, it could be 30+ files, but with minimal or no other business logic change. + +* **PRs should be well-described.** This allows for teammates to understand the problem and what the PR sets out to do. Importantly, it also allows for verification of the code and is well-documented for posterity. + +* **PRs should be well-tested.** Any change in code will impact flows. These flows should be well-tested. These can be manually tested and unit tested. Additionally, a QA regression test could be added. + +* **Consider who the reviewers are.** Reviewers are ideally owners of the codebase and/or those with deep knowledge of the domain. By reaching out and finding dedicated reviewers early in the process, it also gives a heads up to the reviewers, allowing them to schedule and prioritize reviews. + +* **Budget time for reviews.** Allow the reviewers time to comment and suggest. Even more importantly, allow there to be time to make improvements. Code is written once, but read much more times. + +* **Consider hosting a synchronous, live review.** Sometimes, it’s easier to communicate live with the reviewers to align (or disagree and commit). Please work the alignment back into the PR for posterity. + +* **Examples:** + + * [https://github.cbhq.net/wallet/wallet-mobile/pull/27738](https://github.cbhq.net/wallet/wallet-mobile/pull/27738) + * [https://github.cbhq.net/wallet/wallet-mobile/pull/26092](https://github.cbhq.net/wallet/wallet-mobile/pull/26092) + +## Reviewing {#reviewing} + +* **PRs should be reviewed within half a day.** This is one of the things worth prioritizing for teammates as it generates a flywheel to improve velocity and knowledge-sharing. At the same time, PRs should be relatively easy to review, given the description, self-review, and code quality. + +* **PRs should be reviewed in detail.** No rubber stamping. + +## Owning a Codebase {#owning-a-codebase} + +**Unit Test** +[Base Wallet Unit Test + Lint SLAs](https://docs.google.com/document/u/0/d/1Ai3UDVDR3Hq1P-smfaeuclxDMQYSJjwlAPFyERraJCI/edit) + +**Unit Test Thresholds** +The owners should decide on unit test thresholds. These thresholds should reflect the appropriate LOE and risk for the business given what code is responsible for. + +**Conventions** +The team should have consensus on conventions, or lack of. Ideally, conventions are automated or linted. Else, they should be documented. + +# Appendix {#appendix} + +## FAQ {#faq} + +**There is a tight timeline and it’s easier to get everything into 1 humongous PR. Can we make an exception?** +Short answer: yes, we can always make an exception. There is no hard and fast rule. If there are humongous PRs, I’d recommend having a retro on it to see what could have been done differently. + +**When should we, as authors, seek out reviewers?** +Short answer: as early as possible. This can differ based on the type of work. + +If there is an artifact (PPS/TDD), the reviewers of the artifact likely should also be pull request reviewers. Transitively, reviewers of the pull requests should be reviewers of the artifact. + +## Resources {#resources} + +* [\[Code Red\] Bar Raiser Code Review Program](https://docs.google.com/document/d/1bzYI2gdnNZI9MqvHyTrD7aZRUfrakVedLRe2gw8b114/edit?tab=t.0#heading=h.ismr2neqrl10) +* [Wallet Pull Request Guild (PRG) Readout](https://docs.google.com/document/u/0/d/1nyE26o9DwQnTstJBrwMYgr6qdQPe71YrluzyiMOU89A/edit) + +## Notes {#notes} + +Oct 24, 2024 + +Questions + +* What are our actual problems with our current code and review process? + * Breaking ERC specs + * Break spec on eth request accounts for Pano + * Documentation may have solved this + * Additional parameter on connection + * Time to review is longer than ideal + * Observation: authors repost requesting reviews in Slack + * Hypotheses + * Lack of context + * Lack of ownership +* Does having people not labeled as “Bar Raiser” set the wrong culture? + * Do we want a culture where some people can absolve themselves of the responsibility to raise the bar? +* Regardless of bar-raisers, we could take it down one level. What do we care about? +* [Wallet Pull Request Guild (PRG) Readout](https://docs.google.com/document/u/0/d/1nyE26o9DwQnTstJBrwMYgr6qdQPe71YrluzyiMOU89A/edit) +* Less in-flight projects +* Implement code owners + +\> Bar Raisers for a given component or system are a subset of the broader owning team, typically consisting of more experienced engineers. For repositories or subdirectories with Bar Raisers, PRs must be either authored by a Bar Raiser or receive approval from one before merging. All existing review and merge rules still apply in addition to the Bar Raiser requirement. + +Domains + +* Transaction / Signing: [Cody Crozier](mailto:cody.crozier@coinbase.com), [Lukas Rosario](mailto:lukas.rosario@coinbase.com), [Arjun Dureja](mailto:arjun.dureja@coinbase.com) +* Sessions: [Spencer Stock](mailto:spencer.stock@coinbase.com), [Jake Feldman](mailto:jake.feldman@coinbase.com), [Felix Zhang](mailto:felix.zhang@coinbase.com) +* SDK: [Felix Zhang](mailto:felix.zhang@coinbase.com), [Jake Feldman](mailto:jake.feldman@coinbase.com), [Spencer Stock](mailto:spencer.stock@coinbase.com), [Conner Swenberg](mailto:conner.swenberg@coinbase.com) +* BE: [Sam Luo](mailto:sam.luo@coinbase.com), [Adam Hodges](mailto:adam.hodges@coinbase.com) +* Smart contracts: [Amie Corso](mailto:amie.corso@coinbase.com), [Conner Swenberg](mailto:conner.swenberg@coinbase.com) +* Infra: ? + +Proposal + +* Opt-in ✅ +* Everyone should maintain code and hold a high bar (be a bar raiser) ✅ +* Further discussion + * What it means to be a PR reviewer + * What improvements we can make + * Faster PR reviews + * Higher quality +* Breaking ERC specs (retro this) +* Other ways we can raise the bar \ No newline at end of file diff --git a/context/Mini TDD - TIPS 4337 Bundler .docx b/context/Mini TDD - TIPS 4337 Bundler .docx new file mode 100644 index 0000000000000000000000000000000000000000..e41bf4d517fc7e5d80e1774183bfad340068e417 GIT binary patch literal 306862 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

P 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⪼gur22o-ayr4tT<7=!_bfa746I!U4TYky@RS_N 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%0D1yL!zE{$mxcnsU<|vh|L)9@ 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 z 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%0DoO7-Y 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

^ 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 z

lVqchJmm`$=t4tc04jErQ_MFR<$%vhpzOjnnQp!e+it~$qCP%2?vO1S|eSJ`;e zQQu?`sqg*)WVEX#j;4_gyLT^xxJ7*<0ARAs>P4A#==FRHgWj>fZ_^%&nAQ1XG@yMG zwm2EP`9+cgf~uT8ukXwaxP7Kk{|v@=a^4ndf$`$@3eRcKNaFJp_q>{B%~Id{klpvB z#`)|Ht=+4SqPZ2f=RYw^*tPMzn|^nBbDu9lD35s7aon=H`>%RWH8u@u{4AttD^|^Fpn5D{Uih5$-;to~_QU8v1iS-)$$~n?2 z8R%L)-Y*i2ruj++N2iq%XIws;OPo%Z(*T?CUlH^vUs=t+{^?u8#7Y2^0J5$ZU9s@|Zeo*k6T5XA!ZKe49@Xi93KxLlDhBagD;8vg z_NR%@Dl|zlm{zn!sxA#a6^LDVa_uZ?GX|;LJS~XRjf!14gHUdaKfQlQ>RJW0T$Y7c zQ(;kC5^845?Lo4j-oQ+Z8DFtDDmRmV`z@M7VWrb(p~p5oQ+GbOg!c9;(P-QX1XVbY zTd3U*kDbSYd5?g4Wp&{0oHPMLWCejV?W#W1trRKygbDM2GWK;r86 z0D$fgi(km`SE)R5u1#+g#nT75R39KqC59Awby!OW?`=smXab(i-Qis$8Qj_d@oQ$D z_-!aF0M6GdGzJcoGL!^4#n%6fBlGg1Jr9Lg`o!~a#O0mMl~8;TDXGdD7};X>O-HlC zi~Uwi<1;zw*4p_9pDRTw=g$G-g$*HVcGSAtU5p#?$GRrzKz`&NXxeq=tY9gGHP+_Y z2Tv3O3CqaScVYuCW+^}D88|~E+xmg(yN(k6eCpZes)BUf%%oHNvj}=bex;s^4uNCL zdKYy%p{8|e3VQx7_PzDCkr@8zw9a$Xj30X6K5S*|d)HifdHnj`QnD|we~rFrx+x#! z{b|{4b~C8P0reK3Cji8OO5`%* z5*nvyz5D=5ru#!>b{$!|Y!Gi#IRl&BgpzrO9mkAqZ{xB+R^o{xJsd0R9MesOLcH)! zoA;gJJ2=~lsqKy1G0#Bfoij?mkiL|?8^mzMmhl?s^MC>%6jZ-Kp~=s^Z7cm;pNwVO zm~rmaaG!v4`poS^V3r#UxC>V;ei`^n@OIn)C5HDInV zEax8b%r(%zg7CpGkRRf|SXTMga!1O?VBdAtY;Q_(+ zUV#F3iatK~-LoGoPFP90^X%8!Qk=%XM0?~FOCR0|r!@UW4%2H}tFs-{3&^6SNn|?9 z5hB5?1$NbMYm*)P`Ft9U%TvU1*mC53vFm-E39S@M-VCAS>Y;2 zH=pg&!8=DV2z?rdiT8e8OPZ^{J6Bb2W=-BvFx2h-5yk%*OsRvOnbz)CI#gYge2D(~ z(IWDx&)mVS2-QjPZ)96x_C7;$b#4VNgVom6pJp7?L_j_@JVR8f?*o0&Z(GI0rG7qs zb`;ZJU;T=N9*^TpVWaS*x8@m!dg1DXjji`S(BafL*6mo-jBPckru;o4r}$9kMN1hN zToSI?UR?IK1(Q>!u4I`0lKlD4g1?gng$QGv!BVa2}v&X-W8`l(V{Fw7Bzb7S{@N+5aDtn6CjYY>5vQm{v9Eh(;T*i6ib zw@7n?`A>BA?5&(6f;Peid2`7Lx*TSBG9+?o5hDvfhae!Q-;ge&^4nX2j>?_{Q@5N^ zO=>90Zyg%}ds`eL_4J6K4cXoFsx3_Ha}8F}T}D3n^J2EO;?JyFSeksTT4=(uUp>Ef zidigelAg$h-lJt;GKqUE#h@kZF-ucVnY_A47Ge#B?FtO6xTWV6GffhN9z9s*vU@ZU$E|d_S$lXKIvTS%X1mU z-7VzI$N`9t?6URSsL6HxXjkVr4vJoYiSAi%)iPZhMV~GGw%>68S~c1;%%s>xwx

  • Xgrn*5n9 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

    @iP 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

    )uh33KVSk0QPj073C*#XM|fTr`{8KH)s` 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 z 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%0D9I-yZ&n=CL2#ZjMlo`1|Fz18Q6?t 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 CjT;{T literal 0 HcmV?d00001