Allow access to associated storage for new accounts deployed with a staked factory (#202)

Author: hazim-j

.github/workflows/compliance.yml

@@ -31,7 +31,6 @@ jobs:
       - name: Checkout bundler spec test
         uses: actions/checkout@v3
         with:
-          # TODO: Revert back to eth-infinitism/bundler-spec-tests once PR #23 and #24 merged.
           repository: hazim-j/bundler-spec-tests
           ref: develop
           path: ./bundler-spec-tests

internal/config/values.go

@@ -76,7 +76,7 @@ func GetValues() *Values {
 	viper.SetDefault("erc4337_bundler_port", 4337)
 	viper.SetDefault("erc4337_bundler_data_directory", "/tmp/stackup_bundler")
 	viper.SetDefault("erc4337_bundler_supported_entry_points", "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789")
-	viper.SetDefault("erc4337_bundler_max_verification_gas", 1500000)
+	viper.SetDefault("erc4337_bundler_max_verification_gas", 3000000)
 	viper.SetDefault("erc4337_bundler_max_batch_gas_limit", 25000000)
 	viper.SetDefault("erc4337_bundler_max_ops_for_unstaked_sender", 4)
 	viper.SetDefault("erc4337_bundler_blocks_in_the_future", 25)

pkg/entrypoint/simulation/storageslots.go

@@ -41,6 +41,23 @@ func newStorageSlotsByEntity(stakes EntityStakes, keccak []string) storageSlotsB
 	return storageSlotsByEntity
 }
 
+type storageSlotsValidator struct {
+	// Global parameters
+	Op         *userop.UserOperation
+	EntryPoint common.Address
+
+	// Parameters of specific entities required for all validation
+	SenderSlots     storageSlots
+	FactoryIsStaked bool
+
+	// Parameters of the entity under validation
+	EntityName     string
+	EntityAddr     common.Address
+	EntityAccess   tracer.AccessMap
+	EntitySlots    storageSlots
+	EntityIsStaked bool
+}
+
 func isAssociatedWith(slots storageSlots, slot string) bool {
 	slotN, _ := big.NewInt(0).SetString(fmt.Sprintf("0x%s", slot), 0)
 	for _, k := range slots.ToSlice() {
@@ -53,26 +70,18 @@ func isAssociatedWith(slots storageSlots, slot string) bool {
 	return false
 }
 
-func validateStorageSlotsForEntity(
-	entityName string,
-	op *userop.UserOperation,
-	entryPoint common.Address,
-	slotsByEntity storageSlotsByEntity,
-	entityAccess tracer.AccessMap,
-	entityAddr common.Address,
-	entityIsStaked bool,
-) error {
-	senderSlots, senderSlotOk := slotsByEntity[op.Sender]
-	if !senderSlotOk {
+func (v *storageSlotsValidator) Process() error {
+	senderSlots := v.SenderSlots
+	if senderSlots == nil {
 		senderSlots = mapset.NewSet[string]()
 	}
-	storageSlots, entitySlotOk := slotsByEntity[entityAddr]
-	if !entitySlotOk {
-		storageSlots = mapset.NewSet[string]()
+	entitySlots := v.EntitySlots
+	if entitySlots == nil {
+		entitySlots = mapset.NewSet[string]()
 	}
 
-	for addr, access := range entityAccess {
-		if addr == op.Sender || addr == entryPoint {
+	for addr, access := range v.EntityAccess {
+		if addr == v.Op.Sender || addr == v.EntryPoint {
 			continue
 		}
 
@@ -84,24 +93,25 @@ func validateStorageSlotsForEntity(
 		for key, slotCount := range accessTypes {
 			for slot := range slotCount {
 				if isAssociatedWith(senderSlots, slot) {
-					if len(op.InitCode) > 0 {
+					if (len(v.Op.InitCode) > 0 && !v.FactoryIsStaked) ||
+						(len(v.Op.InitCode) > 0 && v.FactoryIsStaked && v.EntityAddr != v.Op.Sender) {
 						mustStakeSlot = slot
 					} else {
 						continue
 					}
-				} else if isAssociatedWith(storageSlots, slot) || addr == entityAddr {
+				} else if isAssociatedWith(entitySlots, slot) || addr == v.EntityAddr {
 					mustStakeSlot = slot
 				} else {
-					return fmt.Errorf("%s has forbidden %s to %s slot %s", entityName, key, addr2KnownEntity(op, addr), slot)
+					return fmt.Errorf("%s has forbidden %s to %s slot %s", v.EntityName, key, addr2KnownEntity(v.Op, addr), slot)
 				}
 			}
 		}
 
-		if mustStakeSlot != "" && !entityIsStaked {
+		if mustStakeSlot != "" && !v.EntityIsStaked {
 			return fmt.Errorf(
 				"unstaked %s accessed %s slot %s",
-				entityName,
-				addr2KnownEntity(op, addr),
+				v.EntityName,
+				addr2KnownEntity(v.Op, addr),
 				mustStakeSlot,
 			)
 		}

pkg/entrypoint/simulation/tracevalidation.go

@@ -89,15 +89,18 @@ func TraceSimulateValidation(
 
 	slotsByEntity := newStorageSlotsByEntity(stakes, res.Keccak)
 	for title, entity := range knownEntity {
-		if err := validateStorageSlotsForEntity(
-			title,
-			op,
-			entryPoint,
-			slotsByEntity,
-			entity.Info.Access,
-			entity.Address,
-			entity.IsStaked,
-		); err != nil {
+		v := &storageSlotsValidator{
+			Op:              op,
+			EntryPoint:      entryPoint,
+			SenderSlots:     slotsByEntity[op.Sender],
+			FactoryIsStaked: knownEntity["factory"].IsStaked,
+			EntityName:      title,
+			EntityAddr:      entity.Address,
+			EntityAccess:    entity.Info.Access,
+			EntitySlots:     slotsByEntity[entity.Address],
+			EntityIsStaked:  entity.IsStaked,
+		}
+		if err := v.Process(); err != nil {
 			return nil, err
 		}
 	}