Implement starknet_estimateMessageFee

node/node.go

@@ -264,6 +264,11 @@ func makeRPC(httpPort, wsPort uint16, rpcHandler *rpc.Handler, log utils.SimpleL
 			Params:  []jsonrpc.Parameter{{Name: "request"}, {Name: "block_id"}},
 			Handler: rpcHandler.EstimateFee,
 		},
+		{
+			Name:    "starknet_estimateMessageFee",
+			Params:  []jsonrpc.Parameter{{Name: "message"}, {Name: "block_id"}},
+			Handler: rpcHandler.EstimateMessageFee,
+		},
 	}
 
 	jsonrpcServer := jsonrpc.NewServer(log).WithValidator(validator.Validator())

rpc/handlers.go

@@ -1082,8 +1082,9 @@ func (h *Handler) EstimateFee(broadcastedTxns []BroadcastedTransaction, id Block
 	var txns []core.Transaction
 	var classes []core.Class
 
+	var paidFeeOnL1_ *felt.Felt
 	for idx := range broadcastedTxns {
-		txn, declaredClass, aErr := adaptBroadcastedTransaction(&broadcastedTxns[idx], h.network)
+		txn, declaredClass, paidFeeOnL1, aErr := adaptBroadcastedTransaction(&broadcastedTxns[idx], h.network)
 		if aErr != nil {
 			return nil, jsonrpc.Err(jsonrpc.InvalidParams, aErr.Error())
 		}
@@ -1092,6 +1093,7 @@ func (h *Handler) EstimateFee(broadcastedTxns []BroadcastedTransaction, id Block
 		if declaredClass != nil {
 			classes = append(classes, declaredClass)
 		}
+		paidFeeOnL1_ = paidFeeOnL1
 	}
 
 	blockNumber := header.Number
@@ -1103,7 +1105,7 @@ func (h *Handler) EstimateFee(broadcastedTxns []BroadcastedTransaction, id Block
 		blockNumber = height + 1
 	}
 
-	gasesConsumed, err := vm.Execute(txns, classes, blockNumber, header.Timestamp, header.SequencerAddress, state, h.network)
+	gasesConsumed, err := vm.Execute(txns, classes, blockNumber, header.Timestamp, header.SequencerAddress, state, h.network, paidFeeOnL1_)
 	if err != nil {
 		rpcErr := *ErrContractError
 		rpcErr.Data = err.Error()
@@ -1120,3 +1122,28 @@ func (h *Handler) EstimateFee(broadcastedTxns []BroadcastedTransaction, id Block
 
 	return estimates, nil
 }
+
+func (h *Handler) EstimateMessageFee(msg MsgFromL1, id BlockID) (*FeeEstimate, *jsonrpc.Error) {
+	calldata := make([]*felt.Felt, 0, len(msg.Payload)+1)
+	// The order of the calldata parameters matters. msg.From must be prepended.
+	calldata = append(calldata, new(felt.Felt).SetBytes(msg.From.Bytes()))
+	calldata = append(calldata, msg.Payload...)
+	tx := BroadcastedTransaction{
+		Transaction: Transaction{
+			Type:               TxnL1Handler,
+			ContractAddress:    msg.To,
+			EntryPointSelector: msg.Selector,
+			CallData:           &calldata,
+			Version:            new(felt.Felt), // Needed for transaction hash calculation.
+			Nonce:              new(felt.Felt), // Needed for transaction hash calculation.
+		},
+		// Needed to marshal to blockifier type.
+		// Must be greater than zero to successfully execute transaction.
+		PaidFeeOnL1: new(felt.Felt).SetUint64(1),
+	}
+	estimates, rpcErr := h.EstimateFee([]BroadcastedTransaction{tx}, id)
+	if rpcErr != nil {
+		return nil, rpcErr
+	}
+	return &estimates[0], nil
+}

rpc/transaction.go

@@ -85,6 +85,16 @@ type Transaction struct {
 	CompiledClassHash   *felt.Felt      `json:"compiled_class_hash,omitempty" validate:"required_if=Type DECLARE Version 0x2"`
 }
 
+type MsgFromL1 struct {
+	// The address of the L1 contract sending the message.
+	From common.Address `json:"from_address" validate:"required"`
+	// The address of the L1 contract sending the message.
+	To *felt.Felt `json:"to_address" validate:"required"`
+	// The payload of the message.
+	Payload  []*felt.Felt `json:"payload" validate:"required"`
+	Selector *felt.Felt   `json:"entry_point_selector" validate:"required"`
+}
+
 type MsgToL1 struct {
 	From    *felt.Felt     `json:"from_address"`
 	To      common.Address `json:"to_address"`
@@ -128,6 +138,7 @@ type DeclareTxResponse struct {
 type BroadcastedTransaction struct {
 	Transaction
 	ContractClass json.RawMessage `json:"contract_class,omitempty" validate:"required_if=Transaction.Type DECLARE"`
+	PaidFeeOnL1   *felt.Felt      `json:"paid_fee_on_l1,omitempty" validate:"required_if=Transaction.Type L1_HANDLER"`
 }
 
 type FeeEstimate struct {
@@ -136,34 +147,37 @@ type FeeEstimate struct {
 	OverallFee  *felt.Felt `json:"overall_fee"`
 }
 
-func adaptBroadcastedTransaction(broadcastedTxn *BroadcastedTransaction, network utils.Network) (core.Transaction, core.Class, error) {
+//nolint:gocyclo
+func adaptBroadcastedTransaction(broadcastedTxn *BroadcastedTransaction,
+	network utils.Network,
+) (core.Transaction, core.Class, *felt.Felt, error) {
 	var feederTxn feeder.Transaction
 	if err := copier.Copy(&feederTxn, broadcastedTxn.Transaction); err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 	feederTxn.Type = broadcastedTxn.Type.String()
 
 	txn, err := feeder2core.AdaptTransaction(&feederTxn)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
 	var declaredClass core.Class
 	if len(broadcastedTxn.ContractClass) != 0 {
 		declaredClass, err = adaptDeclaredClass(broadcastedTxn.ContractClass)
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
 	} else if broadcastedTxn.Type == TxnDeclare {
-		return nil, nil, errors.New("declare without a class definition")
+		return nil, nil, nil, errors.New("declare without a class definition")
 	}
 
 	if t, ok := txn.(*core.DeclareTransaction); ok {
 		switch c := declaredClass.(type) {
 		case *core.Cairo0Class:
 			t.ClassHash, err = vm.Cairo0ClassHash(c)
 			if err != nil {
-				return nil, nil, err
+				return nil, nil, nil, err
 			}
 		case *core.Cairo1Class:
 			t.ClassHash = c.Hash()
@@ -172,22 +186,26 @@ func adaptBroadcastedTransaction(broadcastedTxn *BroadcastedTransaction, network
 
 	txnHash, err := core.TransactionHash(txn, network)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, nil, err
 	}
 
+	var paidFeeOnL1 *felt.Felt
 	switch t := txn.(type) {
 	case *core.DeclareTransaction:
 		t.TransactionHash = txnHash
 	case *core.InvokeTransaction:
 		t.TransactionHash = txnHash
 	case *core.DeployAccountTransaction:
 		t.TransactionHash = txnHash
+	case *core.L1HandlerTransaction:
+		t.TransactionHash = txnHash
+		paidFeeOnL1 = broadcastedTxn.PaidFeeOnL1
 	default:
-		return nil, nil, errors.New("unsupported transaction")
+		return nil, nil, nil, errors.New("unsupported transaction")
 	}
 
 	if txn.Hash() == nil {
-		return nil, nil, errors.New("deprecated transaction type")
+		return nil, nil, nil, errors.New("deprecated transaction type")
 	}
-	return txn, declaredClass, nil
+	return txn, declaredClass, paidFeeOnL1, nil
 }

vm/rust/Makefile

@@ -2,4 +2,4 @@ all:
 	cargo build --release
 
 clean:
-	rm -rf target
+	rm -rf target

vm/rust/src/lib.rs

@@ -18,9 +18,16 @@ use blockifier::{
     },
     state::cached_state::CachedState,
     transaction::{
-        objects::AccountTransactionContext, transaction_execution::Transaction,
-        transactions::ExecutableTransaction,
+        objects::{
+            AccountTransactionContext, TransactionExecutionInfo,
+        }, transaction_execution::Transaction,
+        transactions::{
+            ExecutableTransaction, Executable,
+        },
+        transaction_utils::calculate_tx_resources,
+        transaction_types::TransactionType,
     },
+    fee::fee_utils::calculate_tx_fee,
 };
 use cairo_lang_starknet::casm_contract_class::CasmContractClass;
 use cairo_lang_starknet::contract_class::ContractClass as SierraContractClass;
@@ -34,10 +41,11 @@ use starknet_api::{
     block::{BlockNumber, BlockTimestamp},
     deprecated_contract_class::EntryPointType,
     hash::StarkFelt,
+    transaction::TransactionSignature,
 };
 use starknet_api::{
     core::PatriciaKey,
-    transaction::{Calldata, Transaction as StarknetApiTransaction},
+    transaction::{Calldata, Transaction as StarknetApiTransaction, Fee},
 };
 use starknet_api::{
     core::{ChainId, ContractAddress, EntryPointSelector},
@@ -120,6 +128,7 @@ pub extern "C" fn cairoVMExecute(
     block_timestamp: c_ulonglong,
     chain_id: *const c_char,
     sequencer_address: *const c_uchar,
+    paid_fee_on_l1_str: *const c_char,
 ) {
     let reader = JunoStateReader::new(reader_handle);
     let chain_id_str = unsafe { CStr::from_ptr(chain_id) }.to_str().unwrap();
@@ -177,15 +186,92 @@ pub extern "C" fn cairoVMExecute(
             _ => None,
         };
 
-        let txn = Transaction::from_api(sn_api_txn.clone(), contract_class, None);
+        let paid_fee_on_l1: Option<Fee> = match sn_api_txn.clone() {
+            StarknetApiTransaction::L1Handler(_) => {
+                let paid_fee_on_l1_str = unsafe { CStr::from_ptr(paid_fee_on_l1_str) }.to_str().unwrap();
+                let paid_fee_on_l1 = match u128::from_str_radix(paid_fee_on_l1_str, 16) {
+                    Ok(i) => Fee(i),
+                    Err(e) => {
+                        report_error(reader_handle, format!("failed to convert string to u128 reason:{:?}", e).as_str());
+                        return;
+                    }
+                }
+                ;
+                Some(paid_fee_on_l1)
+            },
+            _ => None,
+        };
+
+
+        let txn = Transaction::from_api(sn_api_txn.clone(), contract_class, paid_fee_on_l1);
         if txn.is_err() {
             report_error(reader_handle, txn.unwrap_err().to_string().as_str());
             return;
         }
 
         let res = match txn.unwrap() {
             Transaction::AccountTransaction(t) => t.execute(&mut state, &block_context),
-            Transaction::L1HandlerTransaction(t) => t.execute(&mut state, &block_context),
+            Transaction::L1HandlerTransaction(t) => {
+                // Manually inline L1HandlerTransaction.execute and execute_raw since the
+                // `actual_fee` in Blockifier is zero (i.e., don't charge for L1
+                // Handler transactions on L2). This way we can get the full
+                // TransactionExecutionResult.
+                // https://github.com/starkware-libs/blockifier/issues/734
+                let mut transactional_state = CachedState::create_transactional(&mut state);
+                // Inlined L1HandlerTransaction.execute_raw
+                let execution_result = || -> Result<TransactionExecutionInfo, _> {
+                    let tx = &t.tx;
+                    let tx_context = AccountTransactionContext {
+                        transaction_hash: tx.transaction_hash,
+                        max_fee: Fee::default(),
+                        version: tx.version,
+                        signature: TransactionSignature::default(),
+                        nonce: tx.nonce,
+                        sender_address: tx.contract_address,
+                    };
+                    let mut resources = ExecutionResources::default();
+                    let mut context = EntryPointExecutionContext::new(
+                        block_context.clone(),
+                        tx_context,
+                        block_context.invoke_tx_max_n_steps,
+                        );
+                    let mut remaining_gas = Transaction::initial_gas();
+                    let execute_call_info =
+                        t.run_execute(&mut transactional_state, &mut resources, &mut context, &mut remaining_gas)?;
+
+                    let call_infos =
+                        if let Some(call_info) = execute_call_info.as_ref() { vec![call_info] } else { vec![] };
+                    // The calldata includes the "from" field, which is not a part of the payload.
+                    let l1_handler_payload_size = Some(tx.calldata.0.len() - 1);
+                    let actual_resources = calculate_tx_resources(
+                        resources,
+                        &call_infos,
+                        TransactionType::L1Handler,
+                        &mut transactional_state,
+                        l1_handler_payload_size,
+                        )?;
+                    let actual_fee = calculate_tx_fee(&actual_resources, &context.block_context)?;
+
+                    Ok(TransactionExecutionInfo {
+                        validate_call_info: None,
+                        execute_call_info,
+                        fee_transfer_call_info: None,
+                        actual_fee,
+                        actual_resources,
+                    })
+                }();
+
+                match execution_result {
+                    Ok(value) => {
+                        transactional_state.commit();
+                        Ok(value)
+                    }
+                    Err(error) => {
+                        transactional_state.abort();
+                        Err(error)
+                    }
+                }
+            },
         };
 
         match res {

vm/transaction.go

@@ -40,6 +40,8 @@ func marshalTxn(txn core.Transaction) (json.RawMessage, error) {
 		txnMap["Declare"] = map[string]any{
 			"V" + clearQueryBit(t.Version).Text(felt.Base10): t,
 		}
+	case *core.L1HandlerTransaction:
+		txnMap["L1Handler"] = t
 	default:
 		return nil, errors.New("unsupported txn type")
 	}

vm/vm.go

@@ -8,7 +8,7 @@ package vm
 //					char* chain_id);
 //
 // extern void cairoVMExecute(char* txns_json, char* classes_json, uintptr_t readerHandle, unsigned long long block_number,
-//					unsigned long long block_timestamp, char* chain_id, char* sequencer_address);
+//					unsigned long long block_timestamp, char* chain_id, char* sequencer_address, char* paid_fee_on_l1);
 //
 // #cgo LDFLAGS: -L./rust/target/release -ljuno_starknet_rs -lm -ldl
 import "C"
@@ -117,7 +117,7 @@ func Call(contractAddr, selector *felt.Felt, calldata []felt.Felt, blockNumber,
 
 // Execute executes a given transaction set and returns the gas spent per transaction
 func Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber, blockTimestamp uint64,
-	sequencerAddress *felt.Felt, state core.StateReader, network utils.Network,
+	sequencerAddress *felt.Felt, state core.StateReader, network utils.Network, paidFeeOnL1 *felt.Felt,
 ) ([]*felt.Felt, error) {
 	context := &callContext{
 		state: state,
@@ -130,6 +130,7 @@ func Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber,
 		return nil, err
 	}
 
+	paidFeeOnL1CStr := C.CString(paidFeeOnL1.Text(felt.Base16))
 	txnsJSONCstr := C.CString(string(txnsJSON))
 	classesJSONCStr := C.CString(string(classesJSON))
 
@@ -141,9 +142,11 @@ func Execute(txns []core.Transaction, declaredClasses []core.Class, blockNumber,
 		C.ulonglong(blockNumber),
 		C.ulonglong(blockTimestamp),
 		chainID,
-		(*C.char)(unsafe.Pointer(&sequencerAddressBytes[0])))
+		(*C.char)(unsafe.Pointer(&sequencerAddressBytes[0])),
+		paidFeeOnL1CStr)
 
 	C.free(unsafe.Pointer(classesJSONCStr))
+	C.free(unsafe.Pointer(paidFeeOnL1CStr))
 	C.free(unsafe.Pointer(txnsJSONCstr))
 	C.free(unsafe.Pointer(chainID))