Split resource kind storage access

arbos/l2pricing/l2pricing.go

@@ -206,12 +206,13 @@ func (ps *L2PricingState) setMultiGasConstraintsFromSingleGasConstraints() error
 
 		// Transfer to multi-gas constraint with equal weights
 		weights := map[uint8]uint64{
-			uint8(multigas.ResourceKindComputation):     1,
-			uint8(multigas.ResourceKindHistoryGrowth):   1,
-			uint8(multigas.ResourceKindStorageAccess):   1,
-			uint8(multigas.ResourceKindStorageGrowth):   1,
-			uint8(multigas.ResourceKindL2Calldata):      1,
-			uint8(multigas.ResourceKindWasmComputation): 1,
+			uint8(multigas.ResourceKindComputation):        1,
+			uint8(multigas.ResourceKindHistoryGrowth):      1,
+			uint8(multigas.ResourceKindStorageAccessRead):  1,
+			uint8(multigas.ResourceKindStorageAccessWrite): 1,
+			uint8(multigas.ResourceKindStorageGrowth):      1,
+			uint8(multigas.ResourceKindL2Calldata):         1,
+			uint8(multigas.ResourceKindWasmComputation):    1,
 		}
 
 		var adjustmentWindow uint32

arbos/l2pricing/l2pricing_test.go

@@ -167,8 +167,8 @@ func TestMultiGasConstraints(t *testing.T) {
 	const n uint64 = 5
 	for i := range n {
 		weights := map[uint8]uint64{
-			uint8(multigas.ResourceKindComputation):   10 + i,
-			uint8(multigas.ResourceKindStorageAccess): 20 + i,
+			uint8(multigas.ResourceKindComputation):       10 + i,
+			uint8(multigas.ResourceKindStorageAccessRead): 20 + i,
 		}
 		Require(t,
 			// #nosec G115
@@ -209,8 +209,8 @@ func TestMultiGasConstraints(t *testing.T) {
 		if weights[multigas.ResourceKindComputation] != 10+i {
 			t.Errorf("wrong computation weight: got %v, want %v", weights[multigas.ResourceKindComputation], 10+i)
 		}
-		if weights[multigas.ResourceKindStorageAccess] != 20+i {
-			t.Errorf("wrong storage weight: got %v, want %v", weights[multigas.ResourceKindStorageAccess], 20+i)
+		if weights[multigas.ResourceKindStorageAccessRead] != 20+i {
+			t.Errorf("wrong storage weight: got %v, want %v", weights[multigas.ResourceKindStorageAccessRead], 20+i)
 		}
 	}
 
@@ -242,7 +242,7 @@ func TestMultiGasConstraintsExponents(t *testing.T) {
 		20,
 		200,
 		map[uint8]uint64{
-			uint8(multigas.ResourceKindStorageAccess): 2,
+			uint8(multigas.ResourceKindStorageAccessWrite): 2,
 		},
 	)
 	Require(t, err)
@@ -256,8 +256,8 @@ func TestMultiGasConstraintsExponents(t *testing.T) {
 	}
 
 	expected = arbmath.Bips(2500)
-	if exps[multigas.ResourceKindStorageAccess] != expected {
-		t.Fatalf("wrong exponent: got %v, want %v", exps[multigas.ResourceKindStorageAccess], expected)
+	if exps[multigas.ResourceKindStorageAccessWrite] != expected {
+		t.Fatalf("wrong exponent: got %v, want %v", exps[multigas.ResourceKindStorageAccessWrite], expected)
 	}
 }
 

arbos/l2pricing/model_test.go

@@ -139,8 +139,8 @@ func TestCalcMultiGasConstraintsExponents(t *testing.T) {
 		10,
 		20000,
 		map[uint8]uint64{
-			uint8(multigas.ResourceKindComputation):   1,
-			uint8(multigas.ResourceKindStorageAccess): 2,
+			uint8(multigas.ResourceKindComputation):       1,
+			uint8(multigas.ResourceKindStorageAccessRead): 2,
 		},
 	))
 	Require(t, pricing.AddMultiGasConstraint(
@@ -158,7 +158,7 @@ func TestCalcMultiGasConstraintsExponents(t *testing.T) {
 	if got, want := exponents[multigas.ResourceKindComputation], arbmath.Bips(100); got != want {
 		t.Errorf("unexpected computation exponent: got %v, want %v", got, want)
 	}
-	if got, want := exponents[multigas.ResourceKindStorageAccess], arbmath.Bips(200); got != want {
+	if got, want := exponents[multigas.ResourceKindStorageAccessRead], arbmath.Bips(200); got != want {
 		t.Errorf("unexpected storage-access exponent: got %v, want %v", got, want)
 	}
 
@@ -189,7 +189,7 @@ func TestMultiDimensionalPriceForRefund(t *testing.T) {
 
 	multiGas := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 50000},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 15000},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 15000},
 	)
 	// #nosec G115
 	singleGas := big.NewInt(int64(multiGas.SingleGas()))
@@ -212,22 +212,22 @@ func TestMultiDimensionalPriceForRefund(t *testing.T) {
 		10,
 		20000,
 		map[uint8]uint64{
-			uint8(multigas.ResourceKindComputation):   1,
-			uint8(multigas.ResourceKindStorageAccess): 2,
+			uint8(multigas.ResourceKindComputation):       1,
+			uint8(multigas.ResourceKindStorageAccessRead): 2,
 		},
 	))
 	Require(t, pricing.AddMultiGasConstraint(
 		50000,
 		5,
 		15000,
 		map[uint8]uint64{
-			uint8(multigas.ResourceKindComputation):   2,
-			uint8(multigas.ResourceKindStorageAccess): 1,
+			uint8(multigas.ResourceKindComputation):       2,
+			uint8(multigas.ResourceKindStorageAccessRead): 1,
 		},
 	))
 	usedMultiGas := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 500000},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 1500000},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 1500000},
 	)
 	err = pricing.GrowBacklog(usedMultiGas.SingleGas(), usedMultiGas)
 	Require(t, err)

arbos/l2pricing/multi_gas_constraint_test.go

@@ -30,26 +30,26 @@ func TestMultiGasConstraint(t *testing.T) {
 	require.Equal(t, uint64(789), backlog)
 
 	weightedResources := map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation):   10,
-		uint8(multigas.ResourceKindStorageAccess): 20,
+		uint8(multigas.ResourceKindComputation):       10,
+		uint8(multigas.ResourceKindStorageAccessRead): 20,
 	}
 	require.NoError(t, c.SetResourceWeights(weightedResources))
 
 	w1, _ := c.ResourceWeight(uint8(multigas.ResourceKindComputation))
-	w2, _ := c.ResourceWeight(uint8(multigas.ResourceKindStorageAccess))
+	w2, _ := c.ResourceWeight(uint8(multigas.ResourceKindStorageAccessRead))
 	require.Equal(t, uint64(10), w1)
 	require.Equal(t, uint64(20), w2)
 
 	res, err := c.GetResourceWeights()
 	require.NoError(t, err)
 	require.Equal(t, uint64(10), res[multigas.ResourceKindComputation])
-	require.Equal(t, uint64(20), res[multigas.ResourceKindStorageAccess])
+	require.Equal(t, uint64(20), res[multigas.ResourceKindStorageAccessRead])
 
 	used, err := c.UsedResources()
 	require.NoError(t, err)
 	require.Len(t, used, 2)
 	require.Contains(t, used, multigas.ResourceKindComputation)
-	require.Contains(t, used, multigas.ResourceKindStorageAccess)
+	require.Contains(t, used, multigas.ResourceKindStorageAccessRead)
 
 	maxWeight, err := c.MaxWeight()
 	require.NoError(t, err)
@@ -84,8 +84,8 @@ func TestMultiGasConstraintResourceWeightsValidation(t *testing.T) {
 
 	// valid set
 	valid := map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation):   3,
-		uint8(multigas.ResourceKindStorageAccess): 7,
+		uint8(multigas.ResourceKindComputation):       3,
+		uint8(multigas.ResourceKindStorageAccessRead): 7,
 	}
 	require.NoError(t, c.SetResourceWeights(valid))
 
@@ -102,13 +102,13 @@ func TestMultiGasConstraintBacklogAggregation(t *testing.T) {
 	require.NoError(t, c.SetAdjustmentWindow(2))
 
 	require.NoError(t, c.SetResourceWeights(map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation):   1,
-		uint8(multigas.ResourceKindStorageAccess): 2,
+		uint8(multigas.ResourceKindComputation):       1,
+		uint8(multigas.ResourceKindStorageAccessRead): 2,
 	}))
 
 	mg := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 10},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 10},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 10},
 	)
 
 	require.NoError(t, c.GrowBacklog(mg))
@@ -122,13 +122,13 @@ func TestMultiGasConstraintBacklogGrowth(t *testing.T) {
 	require.NoError(t, c.SetAdjustmentWindow(5))
 
 	require.NoError(t, c.SetResourceWeights(map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation):   1,
-		uint8(multigas.ResourceKindStorageAccess): 2,
+		uint8(multigas.ResourceKindComputation):       1,
+		uint8(multigas.ResourceKindStorageAccessRead): 2,
 	}))
 
 	mg1 := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 10},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 10},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 10},
 	)
 
 	require.NoError(t, c.GrowBacklog(mg1))
@@ -139,7 +139,7 @@ func TestMultiGasConstraintBacklogGrowth(t *testing.T) {
 
 	mg2 := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 5},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 15},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 15},
 	)
 
 	require.NoError(t, c.GrowBacklog(mg2))
@@ -158,14 +158,14 @@ func TestMultiGasConstraintBacklogDecay(t *testing.T) {
 	require.NoError(t, c.SetAdjustmentWindow(5))
 
 	require.NoError(t, c.SetResourceWeights(map[uint8]uint64{
-		uint8(multigas.ResourceKindComputation):   1,
-		uint8(multigas.ResourceKindStorageAccess): 2,
+		uint8(multigas.ResourceKindComputation):       1,
+		uint8(multigas.ResourceKindStorageAccessRead): 2,
 	}))
 
 	// Initial backlog: 1*10 + 2*10 = 30
 	mgGrow := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 10},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 10},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 10},
 	)
 	require.NoError(t, c.GrowBacklog(mgGrow))
 
@@ -176,7 +176,7 @@ func TestMultiGasConstraintBacklogDecay(t *testing.T) {
 	// First decay: 1*3 + 2*4 = 11 → new backlog = 30 - 11 = 19
 	mgDecay1 := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 3},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 4},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 4},
 	)
 	require.NoError(t, c.ShrinkBacklog(mgDecay1))
 
@@ -187,7 +187,7 @@ func TestMultiGasConstraintBacklogDecay(t *testing.T) {
 	// Second decay underflows: 1*50 + 2*50 = 150 → should clamp to zero
 	mgDecay2 := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: 50},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: 50},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: 50},
 	)
 	require.NoError(t, c.ShrinkBacklog(mgDecay2))
 

arbos/programs/programs.go

@@ -416,7 +416,7 @@ func chargeFragmentReadGas(burner burn.Burner, statedb vm.StateDB, addr common.A
 		cost = multigas.ComputationGas(gethParams.WarmStorageReadCostEIP2929)
 	} else {
 		statedb.AddAddressToAccessList(addr)
-		cost = multigas.StorageAccessGas(gethParams.ColdAccountAccessCostEIP2929)
+		cost = multigas.StorageAccessReadGas(gethParams.ColdAccountAccessCostEIP2929)
 	}
 	// charge copy gas
 	words := ToWordSize(codeSize)
@@ -425,7 +425,7 @@ func chargeFragmentReadGas(burner burn.Burner, statedb vm.StateDB, addr common.A
 		log.Trace("fragment copy gas overflow", "address", addr, "codeSize", codeSize, "words", words, "copyGas", gethParams.CopyGas)
 		return vm.ErrGasUintOverflow
 	}
-	if cost, overflow = cost.SafeIncrement(multigas.ResourceKindStorageAccess, copyGas); overflow {
+	if cost, overflow = cost.SafeIncrement(multigas.ResourceKindStorageAccessRead, copyGas); overflow {
 		log.Trace("fragment copy gas overflow", "address", addr, "codeSize", codeSize, "copyGas", copyGas)
 		return vm.ErrGasUintOverflow
 	}
@@ -569,7 +569,7 @@ func (p Programs) SetProgramCached(
 	}
 
 	// pay to cache the program, or to re-cache in case of upcoming revert
-	if err := p.programs.Burner().Burn(multigas.ResourceKindStorageAccess, uint64(program.initCost)); err != nil {
+	if err := p.programs.Burner().Burn(multigas.ResourceKindStorageAccessRead, uint64(program.initCost)); err != nil {
 		return err
 	}
 	moduleHash, err := p.moduleHashes.Get(codeHash)

arbos/storage/storage.go

@@ -137,7 +137,7 @@ func (s *Storage) Account() common.Address {
 }
 
 func (s *Storage) Get(key common.Hash) (common.Hash, error) {
-	err := s.burner.Burn(multigas.ResourceKindStorageAccess, StorageReadCost)
+	err := s.burner.Burn(multigas.ResourceKindStorageAccessRead, StorageReadCost)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -185,7 +185,7 @@ func (s *Storage) Set(key common.Hash, value common.Hash) error {
 		log.Error("Read-only burner attempted to mutate state", "key", key, "value", value)
 		return vm.ErrWriteProtection
 	}
-	err := s.burner.Burn(multigas.ResourceKindStorageAccess, writeCost(value))
+	err := s.burner.Burn(multigas.ResourceKindStorageAccessWrite, writeCost(value))
 	if err != nil {
 		return err
 	}
@@ -334,7 +334,7 @@ func (s *Storage) ClearBytes() error {
 }
 
 func (s *Storage) GetCodeHash(address common.Address) (common.Hash, error) {
-	err := s.burner.Burn(multigas.ResourceKindStorageAccess, StorageCodeHashCost)
+	err := s.burner.Burn(multigas.ResourceKindStorageAccessRead, StorageCodeHashCost)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -395,7 +395,7 @@ func (s *Storage) NewSlot(offset uint64) StorageSlot {
 }
 
 func (ss *StorageSlot) Get() (common.Hash, error) {
-	err := ss.burner.Burn(multigas.ResourceKindStorageAccess, StorageReadCost)
+	err := ss.burner.Burn(multigas.ResourceKindStorageAccessRead, StorageReadCost)
 	if err != nil {
 		return common.Hash{}, err
 	}
@@ -410,7 +410,7 @@ func (ss *StorageSlot) Set(value common.Hash) error {
 		log.Error("Read-only burner attempted to mutate state", "value", value)
 		return vm.ErrWriteProtection
 	}
-	err := ss.burner.Burn(multigas.ResourceKindStorageAccess, writeCost(value))
+	err := ss.burner.Burn(multigas.ResourceKindStorageAccessWrite, writeCost(value))
 	if err != nil {
 		return err
 	}

arbos/tx_processor_multigas_test.go

@@ -109,10 +109,10 @@ func TestEndTxHookMultiGasRefundNormalTx(t *testing.T) {
 
 	gasUsed := gasLimit - gasLeft
 
-	// Distribute used gas equally between computation and storage access.
+	// Distribute used gas equally between computation and storage access read.
 	usedMultiGas := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: gasUsed / 2},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: gasUsed / 2},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: gasUsed / 2},
 	)
 
 	// Set up multi-gas constraints and spin model to produce different multi-dimensional cost.
@@ -184,7 +184,7 @@ func TestEndTxHookMultiGasRefundRetryableTx(t *testing.T) {
 	gasUsed := gasLimit - gasLeft
 	usedMultiGas := multigas.MultiGasFromPairs(
 		multigas.Pair{Kind: multigas.ResourceKindComputation, Amount: gasUsed / 2},
-		multigas.Pair{Kind: multigas.ResourceKindStorageAccess, Amount: gasUsed / 2},
+		multigas.Pair{Kind: multigas.ResourceKindStorageAccessRead, Amount: gasUsed / 2},
 	)
 
 	// Set up multi-gas constraints and spin model to produce a different multi-dimensional cost.

changelog/mrogachev-nit-4654.md

@@ -0,0 +1,2 @@
+### Changed
+- Split `ResourceKindStorageAccess` into `ResourceKindStorageAccessRead` and `ResourceKindStorageAccessWrite` for finer-grained multi-dimensional gas metering