Skip to content

Commit

Permalink
Update TxInfo syscall (starkware-libs#988)
Browse files Browse the repository at this point in the history
  • Loading branch information
@MohammadNassar1
MohammadNassar1 committed Oct 31, 2023
1 parent ad02626 commit 4403876
Showing 1 changed file with 27 additions and 41 deletions.
68 changes: 27 additions & 41 deletions crates/blockifier/src/execution/syscalls/hint_processor.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -108,8 +108,6 @@ pub const INVALID_INPUT_LENGTH_ERROR: &str =
// "Invalid argument";
pub const INVALID_ARGUMENT: &str =
"0x00000000000000000000000000000000496e76616c696420617267756d656e74";
// Each resource bound contains three felts; see struct `Resource`.
pub const RESOURCE_BOUNDS_ELEMENT_SIZE: usize = 3;

/// Executes StarkNet syscalls (stateful protocol hints) during the execution of an entry point
/// call.
Expand Down Expand Up @@ -314,36 +312,30 @@ impl<'a> SyscallHintProcessor<'a> {
}
}

// TODO(Mohammad, 20/10/2023): Refactor to use allocate_data_segment method.
fn allocate_tx_resource_bounds_segment(
&mut self,
vm: &mut VirtualMachine,
context: &CurrentAccountTransactionContext,
) -> SyscallResult<Relocatable> {
let flat_resource_bounds = &context
) -> SyscallResult<(Relocatable, Relocatable)> {
let flat_resource_bounds = context
.resource_bounds
.0
.iter()
.flat_map(|(resource, resource_bounds)| {
let resource_as_int = match resource {
Resource::L1Gas => 0,
Resource::L2Gas => 1,
let resource = match resource {
Resource::L1Gas => StarkFelt::ZERO,
Resource::L2Gas => StarkFelt::ONE,
};

vec![
resource_as_int,
resource_bounds.max_price_per_unit,
resource_bounds.max_amount as u128,
resource,
StarkFelt::from(resource_bounds.max_price_per_unit),
StarkFelt::from(resource_bounds.max_amount),
]
.into_iter()
.map(|value| MaybeRelocatable::from(Felt252::from(value)))
})
.collect();

let resource_bounds_segment_start_ptr =
self.read_only_segments.allocate(vm, flat_resource_bounds)?;

Ok(resource_bounds_segment_start_ptr)
self.allocate_data_segment(vm, flat_resource_bounds)
}

fn execute_syscall<Request, Response, ExecuteCallback>(
Expand Down Expand Up @@ -409,7 +401,6 @@ impl<'a> SyscallHintProcessor<'a> {
self.increment_syscall_count_by(selector, 1);
}

// TODO(Mohammad, 20/10/2023): Refactor to use allocate_data_segment method.
fn allocate_execution_info_segment(
&mut self,
vm: &mut VirtualMachine,
Expand All @@ -430,27 +421,26 @@ impl<'a> SyscallHintProcessor<'a> {
Ok(execution_info_segment_start_ptr)
}

// TODO(Mohammad, 20/10/2023): Refactor to use allocate_data_segment method.
fn allocate_block_info_segment(
&mut self,
vm: &mut VirtualMachine,
) -> SyscallResult<Relocatable> {
let block_context = &self.context.block_context;
let block_info: Vec<MaybeRelocatable> = if self.is_validate_mode() {
let block_info: Vec<StarkFelt> = if self.is_validate_mode() {
vec![
Felt252::zero().into(),
StarkFelt::ZERO,
// TODO(Yoni, 1/5/2024): set the timestamp to be zero for `validate``.
Felt252::from(block_context.block_timestamp.0).into(),
Felt252::zero().into(),
StarkFelt::from(block_context.block_timestamp.0),
StarkFelt::ZERO,
]
} else {
vec![
Felt252::from(block_context.block_number.0).into(),
Felt252::from(block_context.block_timestamp.0).into(),
stark_felt_to_felt(*block_context.sequencer_address.0.key()).into(),
StarkFelt::from(block_context.block_number.0),
StarkFelt::from(block_context.block_timestamp.0),
*block_context.sequencer_address.0.key(),
]
};
let block_info_segment_start_ptr = self.read_only_segments.allocate(vm, &block_info)?;
let (block_info_segment_start_ptr, _) = self.allocate_data_segment(vm, block_info)?;

Ok(block_info_segment_start_ptr)
}
Expand Down Expand Up @@ -490,11 +480,8 @@ impl<'a> SyscallHintProcessor<'a> {

match account_tx_context {
AccountTransactionContext::Current(context) => {
let tx_resource_bounds_start_ptr =
let (tx_resource_bounds_start_ptr, tx_resource_bounds_end_ptr) =
&self.allocate_tx_resource_bounds_segment(vm, &context)?;
let tx_resource_bounds_length = context.resource_bounds.0.len();
let tx_resource_bounds_end_ptr = (*tx_resource_bounds_start_ptr
+ (RESOURCE_BOUNDS_ELEMENT_SIZE * tx_resource_bounds_length))?;

let (tx_paymaster_data_start_ptr, tx_paymaster_data_end_ptr) =
&self.allocate_data_segment(vm, context.paymaster_data.0)?;
Expand All @@ -517,15 +504,15 @@ impl<'a> SyscallHintProcessor<'a> {
AccountTransactionContext::Deprecated(_) => {
let zero_felt: MaybeRelocatable = Felt252::zero().into();
tx_info.extend_from_slice(&[
zero_felt.clone(), // Empty array of resource bounds.
zero_felt.clone(),
zero_felt.clone(), // Empty segment of resource bounds (start ptr).
zero_felt.clone(), // Empty segment of resource bounds (end ptr).
zero_felt.clone(), // Tip.
zero_felt.clone(), // Empty array of paymaster data.
zero_felt.clone(),
zero_felt.clone(), // Empty segment of paymaster data (start ptr).
zero_felt.clone(), // Empty segment of paymaster data (end ptr).
zero_felt.clone(), // Nonce DA mode.
zero_felt.clone(), // Fee DA mode.
zero_felt.clone(), // Empty array of account deployment data.
zero_felt,
zero_felt.clone(), // Empty segment of account deployment data (start ptr).
zero_felt, // Empty segment of account deployment data (end ptr).
]);
}
};
Expand Down Expand Up @@ -675,11 +662,10 @@ pub fn create_retdata_segment(
syscall_handler: &mut SyscallHintProcessor<'_>,
raw_retdata: &[StarkFelt],
) -> SyscallResult<ReadOnlySegment> {
let retdata: Vec<MaybeRelocatable> =
raw_retdata.iter().map(|&x| MaybeRelocatable::from(stark_felt_to_felt(x))).collect();
let retdata_segment_start_ptr = syscall_handler.read_only_segments.allocate(vm, &retdata)?;
let (retdata_segment_start_ptr, _) =
syscall_handler.allocate_data_segment(vm, raw_retdata.to_vec())?;

Ok(ReadOnlySegment { start_ptr: retdata_segment_start_ptr, length: retdata.len() })
Ok(ReadOnlySegment { start_ptr: retdata_segment_start_ptr, length: raw_retdata.len() })
}

pub fn execute_library_call(
Expand Down

0 comments on commit 4403876

Please sign in to comment.