Update blockifier

adapters/core2p2p/receipt.go

@@ -107,7 +107,6 @@ func AdaptExecutionResources(er *core.ExecutionResources) *gen.Receipt_Execution
 	var l1Gas, l1DataGas, l2Gas, totalL1Gas, totalL1DataGas *felt.Felt
 	if da := er.DataAvailability; da != nil { // todo(kirill) check that it might be null
 		l1Gas = new(felt.Felt).SetUint64(da.L1Gas)
-		l2Gas = new(felt.Felt).SetUint64(da.L2Gas)
 		l1DataGas = new(felt.Felt).SetUint64(da.L1DataGas)
 	}
 	if tgs := er.TotalGasConsumed; tgs != nil {

adapters/p2p2core/receipt.go

@@ -58,7 +58,6 @@ func adaptExecutionResources(er *gen.Receipt_ExecutionResources) *core.Execution
 		},
 		DataAvailability: &core.DataAvailability{
 			L1Gas:     feltToUint64(er.L1Gas),
-			L2Gas:     feltToUint64(er.L2Gas),
 			L1DataGas: feltToUint64(er.L1DataGas),
 		},
 		MemoryHoles: uint64(er.MemoryHoles),

core/transaction.go

@@ -105,7 +105,6 @@ type ExecutionResources struct {
 type DataAvailability struct {
 	L1Gas     uint64
 	L1DataGas uint64
-	L2Gas     uint64
 }
 
 type BuiltinInstanceCounter struct {

node/throttled_vm.go

@@ -15,7 +15,7 @@
 
 func NewThrottledVM(res vm.VM, concurrenyBudget uint, maxQueueLen int32) *ThrottledVM {
 	return &ThrottledVM{
-		Throttler: utils.NewThrottler[vm.VM](concurrenyBudget, &res).WithMaxQueueLen(maxQueueLen),
+		Throttler: utils.NewThrottler(concurrenyBudget, &res).WithMaxQueueLen(maxQueueLen),
 	}
 }
 
@@ -30,16 +30,17 @@
 	})
 }
 
-func (tvm *ThrottledVM) Execute(txns []core.Transaction, declaredClasses []core.Class, paidFeesOnL1 []*felt.Felt,
+func (tvm *ThrottledVM) Execute(txns []core.Transaction, declaredClasses []core.Class, paidFeesOnL1 []*felt.Felt, //nolint:gocritic
 	blockInfo *vm.BlockInfo, state core.StateReader, network *utils.Network, skipChargeFee, skipValidate, errOnRevert bool,
-) ([]*felt.Felt, []core.GasConsumed, []vm.TransactionTrace, uint64, error) {
+) ([]*felt.Felt, []core.DataAvailability, []core.GasConsumed, []vm.TransactionTrace, uint64, error) {
 	var ret []*felt.Felt
 	var traces []vm.TransactionTrace
-	var daGas []core.GasConsumed
+	var daGas []core.DataAvailability
+	var gasConsumed []core.GasConsumed
 	var numSteps uint64
-	return ret, daGas, traces, numSteps, tvm.Do(func(vm *vm.VM) error {
+	return ret, daGas, gasConsumed, traces, numSteps, tvm.Do(func(vm *vm.VM) error {
 		var err error
-		ret, daGas, traces, numSteps, err = (*vm).Execute(txns, declaredClasses, paidFeesOnL1, blockInfo, state, network,
+		ret, daGas, gasConsumed, traces, numSteps, err = (*vm).Execute(txns, declaredClasses, paidFeesOnL1, blockInfo, state, network,
 			skipChargeFee, skipValidate, errOnRevert)
 		return err
 	})

rpc/estimate_fee_test.go

@@ -36,7 +36,7 @@ func TestEstimateFee(t *testing.T) {
 	blockInfo := vm.BlockInfo{Header: &core.Header{}}
 	t.Run("ok with zero values", func(t *testing.T) {
 		mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &blockInfo, mockState, n, true, false, true).
-			Return([]*felt.Felt{}, []core.GasConsumed{}, []vm.TransactionTrace{}, uint64(123), nil).Times(2)
+			Return([]*felt.Felt{}, []core.DataAvailability{}, []core.GasConsumed{}, []vm.TransactionTrace{}, uint64(123), nil).Times(2)
 
 		_, httpHeader, err := handler.EstimateFee([]rpc.BroadcastedTransaction{}, []rpc.SimulationFlag{}, rpc.BlockID{Latest: true})
 		require.Nil(t, err)
@@ -50,7 +50,7 @@ func TestEstimateFee(t *testing.T) {
 
 	t.Run("ok with zero values, skip validate", func(t *testing.T) {
 		mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &blockInfo, mockState, n, true, true, true).
-			Return([]*felt.Felt{}, []core.GasConsumed{}, []vm.TransactionTrace{}, uint64(123), nil).Times(2)
+			Return([]*felt.Felt{}, []core.DataAvailability{}, []core.GasConsumed{}, []vm.TransactionTrace{}, uint64(123), nil).Times(2)
 
 		_, httpHeader, err := handler.EstimateFee([]rpc.BroadcastedTransaction{}, []rpc.SimulationFlag{rpc.SkipValidateFlag}, rpc.BlockID{Latest: true})
 		require.Nil(t, err)
@@ -64,7 +64,7 @@ func TestEstimateFee(t *testing.T) {
 
 	t.Run("transaction execution error", func(t *testing.T) {
 		mockVM.EXPECT().Execute([]core.Transaction{}, nil, []*felt.Felt{}, &blockInfo, mockState, n, true, true, true).
-			Return(nil, nil, nil, uint64(0), vm.TransactionExecutionError{
+			Return(nil, nil, nil, nil, uint64(0), vm.TransactionExecutionError{
 				Index: 44,
 				Cause: errors.New("oops"),
 			}).Times(2)

rpc/helpers.go

@@ -115,7 +115,6 @@ func adaptExecutionResources(resources *core.ExecutionResources) *ExecutionResou
 	if da := resources.DataAvailability; da != nil {
 		res.DataAvailability = &DataAvailability{
 			L1Gas:     da.L1Gas,
-			L2Gas:     da.L2Gas,
 			L1DataGas: da.L1DataGas,
 		}
 	}

rpc/simulation.go

@@ -76,14 +76,48 @@
 		return nil, httpHeader, rpcErr
 	}
 
+	txns, classes, paidFeesOnL1, rpcErr := h.prepareTransactions(transactions)
+	if rpcErr != nil {
+		return nil, httpHeader, rpcErr
+	}
+
+	blockHashToBeRevealed, err := h.getRevealedBlockHash(header.Number)
+	if err != nil {
+		return nil, httpHeader, ErrInternal.CloneWithData(err)
+	}
+	blockInfo := vm.BlockInfo{
+		Header:                header,
+		BlockHashToBeRevealed: blockHashToBeRevealed,
+	}
+
+	overallFees, daGas, gasConsumed, traces, numSteps, err := h.vm.Execute(txns, classes, paidFeesOnL1, &blockInfo,
+		state, h.bcReader.Network(), skipFeeCharge, skipValidate, errOnRevert)
+
+	httpHeader.Set(ExecutionStepsHeader, strconv.FormatUint(numSteps, 10))
+
+	if err != nil {
+		return nil, httpHeader, h.handleExecutionError(err)
+	}
+
+	simulatedTransactions, err := h.createSimulatedTransactions(overallFees, traces, gasConsumed, daGas, txns, header)
+	if err != nil {
+		return nil, httpHeader, ErrInternal.CloneWithData(err)
+	}
+
+	return simulatedTransactions, httpHeader, nil
+}
+
+func (h *Handler) prepareTransactions(transactions []BroadcastedTransaction) (
+	[]core.Transaction, []core.Class, []*felt.Felt, *jsonrpc.Error,
+) {
 	txns := make([]core.Transaction, 0, len(transactions))
 	var classes []core.Class
-
 	paidFeesOnL1 := make([]*felt.Felt, 0)
+
 	for idx := range transactions {
 		txn, declaredClass, paidFeeOnL1, aErr := adaptBroadcastedTransaction(&transactions[idx], h.bcReader.Network())
 		if aErr != nil {
-			return nil, httpHeader, jsonrpc.Err(jsonrpc.InvalidParams, aErr.Error())
+			return nil, nil, nil, jsonrpc.Err(jsonrpc.InvalidParams, aErr.Error())
 		}
 
 		if paidFeeOnL1 != nil {
@@ -96,82 +130,87 @@
 		}
 	}
 
-	blockHashToBeRevealed, err := h.getRevealedBlockHash(header.Number)
-	if err != nil {
-		return nil, httpHeader, ErrInternal.CloneWithData(err)
+	return txns, classes, paidFeesOnL1, nil
+}
+
+func (h *Handler) handleExecutionError(err error) *jsonrpc.Error {
+	if errors.Is(err, utils.ErrResourceBusy) {
+		return ErrInternal.CloneWithData(throttledVMErr)
 	}
-	blockInfo := vm.BlockInfo{
-		Header:                header,
-		BlockHashToBeRevealed: blockHashToBeRevealed,
+	var txnExecutionError vm.TransactionExecutionError
+	if errors.As(err, &txnExecutionError) {
+		return makeTransactionExecutionError(&txnExecutionError)
 	}
-	overallFees, daGas, traces, numSteps, err := h.vm.Execute(txns, classes, paidFeesOnL1, &blockInfo,
-		state, h.bcReader.Network(), skipFeeCharge, skipValidate, errOnRevert)
-
-	httpHeader.Set(ExecutionStepsHeader, strconv.FormatUint(numSteps, 10))
+	return ErrUnexpectedError.CloneWithData(err.Error())
+}
 
-	if err != nil {
-		if errors.Is(err, utils.ErrResourceBusy) {
-			return nil, httpHeader, ErrInternal.CloneWithData(throttledVMErr)
-		}
-		var txnExecutionError vm.TransactionExecutionError
-		if errors.As(err, &txnExecutionError) {
-			return nil, httpHeader, makeTransactionExecutionError(&txnExecutionError)
-		}
-		return nil, httpHeader, ErrUnexpectedError.CloneWithData(err.Error())
+func (h *Handler) createSimulatedTransactions(
+	overallFees []*felt.Felt, traces []vm.TransactionTrace, gasConsumed []core.GasConsumed,
+	daGas []core.DataAvailability, txns []core.Transaction, header *core.Header,
+) ([]SimulatedTransaction, error) {
+	if len(overallFees) != len(traces) || len(overallFees) != len(gasConsumed) || len(overallFees) != len(daGas) {
+		return nil, fmt.Errorf("inconsistent lengths: %d overall fees, %d traces, %d gas consumed, %d data availability",
+			len(overallFees), len(traces), len(gasConsumed), len(daGas))
 	}
 
-	result := make([]SimulatedTransaction, 0, len(overallFees))
-	for i, overallFee := range overallFees {
-		feeUnit := feeUnit(txns[i])
+	l1GasPriceWei := header.L1GasPriceETH
+	l1GasPriceStrk := header.L1GasPriceSTRK
+	l2GasPriceWei := &felt.Zero
+	l2GasPriceStrk := &felt.Zero
+	l1DataGasPriceWei := &felt.Zero
+	l1DataGasPriceStrk := &felt.Zero
 
-		estimate := calculateFeeEstimate(overallFee, daGas[i].L1DataGas, feeUnit, header)
+	if gasPrice := header.L2GasPrice; gasPrice != nil {
+		l2GasPriceWei = gasPrice.PriceInWei
+		l2GasPriceStrk = gasPrice.PriceInFri
+	}
+	if gasPrice := header.L1DataGasPrice; gasPrice != nil {
+		l1DataGasPriceWei = gasPrice.PriceInWei
+		l1DataGasPriceStrk = gasPrice.PriceInFri
+	}
 
+	simulatedTransactions := make([]SimulatedTransaction, len(overallFees))
+	for i, overallFee := range overallFees {
 		trace := traces[i]
-		executionResources := trace.TotalExecutionResources()
-		executionResources.DataAvailability = &vm.DataAvailability{
-			L1Gas:     daGas[i].L1Gas,
-			L1DataGas: daGas[i].L1DataGas,
+		traces[i].ExecutionResources = &vm.ExecutionResources{
+			L1Gas:                gasConsumed[i].L1Gas,
+			L1DataGas:            gasConsumed[i].L1DataGas,
+			L2Gas:                gasConsumed[i].L2Gas,
+			ComputationResources: trace.TotalComputationResources(),
+			DataAvailability: &vm.DataAvailability{
+				L1Gas:     daGas[i].L1Gas,
+				L1DataGas: daGas[i].L1DataGas,
+			},
 		}
-		traces[i].ExecutionResources = executionResources
-
-		result = append(result, SimulatedTransaction{
-			TransactionTrace: &traces[i],
-			FeeEstimation:    estimate,
-		})
-	}
 
-	return result, httpHeader, nil
-}
-
-func calculateFeeEstimate(overallFee *felt.Felt, l1DataGas uint64, feeUnit FeeUnit, header *core.Header) FeeEstimate {
-	var l1GasPrice, l2GasPrice, l1DataGasPrice *felt.Felt
-
-	switch feeUnit {
-	case FRI:
-		l1GasPrice = header.L1GasPriceSTRK
-		l2GasPrice = header.L2GasPrice.PriceInFri
-		l1DataGasPrice = header.L1DataGasPrice.PriceInFri
-	case WEI:
-		l1GasPrice = header.L1GasPriceETH
-		l2GasPrice = header.L2GasPrice.PriceInWei
-		l1DataGasPrice = header.L1DataGasPrice.PriceInWei
-	}
+		var l1GasPrice, l2GasPrice, l1DataGasPrice *felt.Felt
+		feeUnit := feeUnit(txns[i])
+		switch feeUnit {
+		case WEI:
+			l1GasPrice = l1GasPriceWei
+			l2GasPrice = l2GasPriceWei
+			l1DataGasPrice = l1DataGasPriceWei
+		case FRI:
+			l1GasPrice = l1GasPriceStrk
+			l2GasPrice = l2GasPriceStrk
+			l1DataGasPrice = l1DataGasPriceStrk
+		}
 
-	l1DataGasConsumed := new(felt.Felt).SetUint64(l1DataGas)
-	dataGasFee := new(felt.Felt).Mul(l1DataGasConsumed, l1DataGasPrice)
-	l1GasConsumed := new(felt.Felt).Sub(overallFee, dataGasFee)
-	l1GasConsumed = l1GasConsumed.Div(l1GasConsumed, l1GasPrice)
-
-	return FeeEstimate{
-		L1GasConsumed:     l1GasConsumed,
-		L2GasConsumed:     &felt.Zero, // TODO: Fix when we have l2 gas price
-		L1GasPrice:        l1GasPrice,
-		L2GasPrice:        l2GasPrice,
-		L1DataGasConsumed: l1DataGasConsumed,
-		L1DataGasPrice:    l1DataGasPrice,
-		OverallFee:        overallFee,
-		Unit:              utils.Ptr(feeUnit),
+		simulatedTransactions[i] = SimulatedTransaction{
+			TransactionTrace: &traces[i],
+			FeeEstimation: FeeEstimate{
+				L1GasConsumed:     new(felt.Felt).SetUint64(gasConsumed[i].L1Gas),
+				L1GasPrice:        l1GasPrice,
+				L2GasConsumed:     new(felt.Felt).SetUint64(gasConsumed[i].L2Gas),
+				L2GasPrice:        l2GasPrice,
+				L1DataGasConsumed: new(felt.Felt).SetUint64(gasConsumed[i].L1DataGas),
+				L1DataGasPrice:    l1DataGasPrice,
+				OverallFee:        overallFee,
+				Unit:              utils.Ptr(feeUnit),
+			},
+		}
 	}
+	return simulatedTransactions, nil
 }
 
 type TransactionExecutionErrorData struct {