Skip to content

Commit 9a509b6

Browse files
aner-starkwareaner-starkware
committed
refactor(blockifier): default secp_syscalls implementation in trait
1 parent c5286b8 commit 9a509b6

File tree

4 files changed

+72
-235
lines changed

4 files changed

+72
-235
lines changed

‎crates/blockifier/src/execution/syscalls/hint_processor.rs

+9-105
Original file line numberDiff line numberDiff line change
@@ -45,21 +45,7 @@ use crate::execution::execution_utils::{
4545
ReadOnlySegment,
4646
ReadOnlySegments,
4747
};
48-
use crate::execution::syscalls::secp::{
49-
Secp256r1NewRequest,
50-
Secp256r1NewResponse,
51-
SecpAddRequest,
52-
SecpAddResponse,
53-
SecpGetPointFromXRequest,
54-
SecpGetPointFromXResponse,
55-
SecpGetXyRequest,
56-
SecpGetXyResponse,
57-
SecpHintProcessor,
58-
SecpMulRequest,
59-
SecpMulResponse,
60-
SecpNewRequest,
61-
SecpNewResponse,
62-
};
48+
use crate::execution::syscalls::secp::SecpHintProcessor;
6349
use crate::execution::syscalls::syscall_base::SyscallHandlerBase;
6450
use crate::execution::syscalls::syscall_executor::{execute_next_syscall, SyscallExecutor};
6551
use crate::execution::syscalls::{
@@ -487,6 +473,14 @@ impl SyscallExecutor for SyscallHintProcessor<'_> {
487473
self.base.keccak(data, remaining_gas)
488474
}
489475

476+
fn get_secpk1_hint_processor(&mut self) -> &mut SecpHintProcessor<ark_secp256k1::Config> {
477+
&mut self.secp256k1_hint_processor
478+
}
479+
480+
fn get_secpr1_hint_processor(&mut self) -> &mut SecpHintProcessor<ark_secp256r1::Config> {
481+
&mut self.secp256r1_hint_processor
482+
}
483+
490484
fn increment_syscall_count_by(&mut self, selector: &SyscallSelector, n: usize) {
491485
let syscall_usage = self.syscalls_usage.entry(*selector).or_default();
492486
syscall_usage.call_count += n;
@@ -737,96 +731,6 @@ impl SyscallExecutor for SyscallHintProcessor<'_> {
737731
Ok(ReplaceClassResponse {})
738732
}
739733

740-
fn secp256k1_add(
741-
request: SecpAddRequest,
742-
_vm: &mut VirtualMachine,
743-
syscall_handler: &mut Self,
744-
_remaining_gas: &mut u64,
745-
) -> SyscallResult<SecpAddResponse> {
746-
syscall_handler.secp256k1_hint_processor.secp_add(request)
747-
}
748-
749-
fn secp256k1_get_point_from_x(
750-
request: SecpGetPointFromXRequest,
751-
vm: &mut VirtualMachine,
752-
syscall_handler: &mut Self,
753-
_remaining_gas: &mut u64,
754-
) -> SyscallResult<SecpGetPointFromXResponse> {
755-
syscall_handler.secp256k1_hint_processor.secp_get_point_from_x(vm, request)
756-
}
757-
758-
fn secp256k1_get_xy(
759-
request: SecpGetXyRequest,
760-
_vm: &mut VirtualMachine,
761-
syscall_handler: &mut Self,
762-
_remaining_gas: &mut u64,
763-
) -> SyscallResult<SecpGetXyResponse> {
764-
syscall_handler.secp256k1_hint_processor.secp_get_xy(request)
765-
}
766-
767-
fn secp256k1_mul(
768-
request: SecpMulRequest,
769-
_vm: &mut VirtualMachine,
770-
syscall_handler: &mut Self,
771-
_remaining_gas: &mut u64,
772-
) -> SyscallResult<SecpMulResponse> {
773-
syscall_handler.secp256k1_hint_processor.secp_mul(request)
774-
}
775-
776-
fn secp256k1_new(
777-
request: SecpNewRequest,
778-
vm: &mut VirtualMachine,
779-
syscall_handler: &mut Self,
780-
_remaining_gas: &mut u64,
781-
) -> SyscallResult<SecpNewResponse> {
782-
syscall_handler.secp256k1_hint_processor.secp_new(vm, request)
783-
}
784-
785-
fn secp256r1_add(
786-
request: SecpAddRequest,
787-
_vm: &mut VirtualMachine,
788-
syscall_handler: &mut Self,
789-
_remaining_gas: &mut u64,
790-
) -> SyscallResult<SecpAddResponse> {
791-
syscall_handler.secp256r1_hint_processor.secp_add(request)
792-
}
793-
794-
fn secp256r1_get_point_from_x(
795-
request: SecpGetPointFromXRequest,
796-
vm: &mut VirtualMachine,
797-
syscall_handler: &mut Self,
798-
_remaining_gas: &mut u64,
799-
) -> SyscallResult<SecpGetPointFromXResponse> {
800-
syscall_handler.secp256r1_hint_processor.secp_get_point_from_x(vm, request)
801-
}
802-
803-
fn secp256r1_get_xy(
804-
request: SecpGetXyRequest,
805-
_vm: &mut VirtualMachine,
806-
syscall_handler: &mut Self,
807-
_remaining_gas: &mut u64,
808-
) -> SyscallResult<SecpGetXyResponse> {
809-
syscall_handler.secp256r1_hint_processor.secp_get_xy(request)
810-
}
811-
812-
fn secp256r1_mul(
813-
request: SecpMulRequest,
814-
_vm: &mut VirtualMachine,
815-
syscall_handler: &mut Self,
816-
_remaining_gas: &mut u64,
817-
) -> SyscallResult<SecpMulResponse> {
818-
syscall_handler.secp256r1_hint_processor.secp_mul(request)
819-
}
820-
821-
fn secp256r1_new(
822-
request: Secp256r1NewRequest,
823-
vm: &mut VirtualMachine,
824-
syscall_handler: &mut Self,
825-
_remaining_gas: &mut u64,
826-
) -> SyscallResult<Secp256r1NewResponse> {
827-
syscall_handler.secp256r1_hint_processor.secp_new(vm, request)
828-
}
829-
830734
fn send_message_to_l1(
831735
request: SendMessageToL1Request,
832736
_vm: &mut VirtualMachine,

‎crates/blockifier/src/execution/syscalls/syscall_executor.rs

+54-27
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,15 @@ use crate::execution::common_hints::HintExecutionResult;
1212
use crate::execution::execution_utils::felt_from_ptr;
1313
use crate::execution::syscalls::hint_processor::{SyscallExecutionError, OUT_OF_GAS_ERROR};
1414
use crate::execution::syscalls::secp::{
15+
Secp256r1NewRequest,
16+
Secp256r1NewResponse,
1517
SecpAddRequest,
1618
SecpAddResponse,
1719
SecpGetPointFromXRequest,
1820
SecpGetPointFromXResponse,
1921
SecpGetXyRequest,
2022
SecpGetXyResponse,
23+
SecpHintProcessor,
2124
SecpMulRequest,
2225
SecpMulResponse,
2326
SecpNewRequest,
@@ -72,6 +75,10 @@ pub trait SyscallExecutor {
7275
remaining_gas: &mut u64,
7376
) -> SyscallResult<([u64; 4], usize)>;
7477

78+
fn get_secpk1_hint_processor(&mut self) -> &mut SecpHintProcessor<ark_secp256k1::Config>;
79+
80+
fn get_secpr1_hint_processor(&mut self) -> &mut SecpHintProcessor<ark_secp256r1::Config>;
81+
7582
fn increment_syscall_count_by(&mut self, selector: &SyscallSelector, count: usize);
7683

7784
fn increment_syscall_count(&mut self, selector: &SyscallSelector) {
@@ -192,73 +199,93 @@ pub trait SyscallExecutor {
192199

193200
fn secp256k1_add(
194201
request: SecpAddRequest,
195-
vm: &mut VirtualMachine,
202+
_vm: &mut VirtualMachine,
196203
syscall_handler: &mut Self,
197-
remaining_gas: &mut u64,
198-
) -> SyscallResult<SecpAddResponse>;
204+
_remaining_gas: &mut u64,
205+
) -> SyscallResult<SecpAddResponse> {
206+
syscall_handler.get_secpk1_hint_processor().secp_add(request)
207+
}
199208

200209
fn secp256k1_get_point_from_x(
201210
request: SecpGetPointFromXRequest,
202211
vm: &mut VirtualMachine,
203212
syscall_handler: &mut Self,
204-
remaining_gas: &mut u64,
205-
) -> SyscallResult<SecpGetPointFromXResponse>;
213+
_remaining_gas: &mut u64,
214+
) -> SyscallResult<SecpGetPointFromXResponse> {
215+
syscall_handler.get_secpk1_hint_processor().secp_get_point_from_x(vm, request)
216+
}
206217

207218
fn secp256k1_get_xy(
208219
request: SecpGetXyRequest,
209-
vm: &mut VirtualMachine,
220+
_vm: &mut VirtualMachine,
210221
syscall_handler: &mut Self,
211-
remaining_gas: &mut u64,
212-
) -> SyscallResult<SecpGetXyResponse>;
222+
_remaining_gas: &mut u64,
223+
) -> SyscallResult<SecpGetXyResponse> {
224+
syscall_handler.get_secpk1_hint_processor().secp_get_xy(request)
225+
}
213226

214227
fn secp256k1_mul(
215228
request: SecpMulRequest,
216-
vm: &mut VirtualMachine,
229+
_vm: &mut VirtualMachine,
217230
syscall_handler: &mut Self,
218-
remaining_gas: &mut u64,
219-
) -> SyscallResult<SecpMulResponse>;
231+
_remaining_gas: &mut u64,
232+
) -> SyscallResult<SecpMulResponse> {
233+
syscall_handler.get_secpk1_hint_processor().secp_mul(request)
234+
}
220235

221236
fn secp256k1_new(
222237
request: SecpNewRequest,
223238
vm: &mut VirtualMachine,
224239
syscall_handler: &mut Self,
225-
remaining_gas: &mut u64,
226-
) -> SyscallResult<SecpNewResponse>;
240+
_remaining_gas: &mut u64,
241+
) -> SyscallResult<SecpNewResponse> {
242+
syscall_handler.get_secpk1_hint_processor().secp_new(vm, request)
243+
}
227244

228245
fn secp256r1_add(
229246
request: SecpAddRequest,
230-
vm: &mut VirtualMachine,
247+
_vm: &mut VirtualMachine,
231248
syscall_handler: &mut Self,
232-
remaining_gas: &mut u64,
233-
) -> SyscallResult<SecpAddResponse>;
249+
_remaining_gas: &mut u64,
250+
) -> SyscallResult<SecpAddResponse> {
251+
syscall_handler.get_secpr1_hint_processor().secp_add(request)
252+
}
234253

235254
fn secp256r1_get_point_from_x(
236255
request: SecpGetPointFromXRequest,
237256
vm: &mut VirtualMachine,
238257
syscall_handler: &mut Self,
239-
remaining_gas: &mut u64,
240-
) -> SyscallResult<SecpGetPointFromXResponse>;
258+
_remaining_gas: &mut u64,
259+
) -> SyscallResult<SecpGetPointFromXResponse> {
260+
syscall_handler.get_secpr1_hint_processor().secp_get_point_from_x(vm, request)
261+
}
241262

242263
fn secp256r1_get_xy(
243264
request: SecpGetXyRequest,
244-
vm: &mut VirtualMachine,
265+
_vm: &mut VirtualMachine,
245266
syscall_handler: &mut Self,
246-
remaining_gas: &mut u64,
247-
) -> SyscallResult<SecpGetXyResponse>;
267+
_remaining_gas: &mut u64,
268+
) -> SyscallResult<SecpGetXyResponse> {
269+
syscall_handler.get_secpr1_hint_processor().secp_get_xy(request)
270+
}
248271

249272
fn secp256r1_mul(
250273
request: SecpMulRequest,
251-
vm: &mut VirtualMachine,
274+
_vm: &mut VirtualMachine,
252275
syscall_handler: &mut Self,
253-
remaining_gas: &mut u64,
254-
) -> SyscallResult<SecpMulResponse>;
276+
_remaining_gas: &mut u64,
277+
) -> SyscallResult<SecpMulResponse> {
278+
syscall_handler.get_secpr1_hint_processor().secp_mul(request)
279+
}
255280

256281
fn secp256r1_new(
257-
request: SecpNewRequest,
282+
request: Secp256r1NewRequest,
258283
vm: &mut VirtualMachine,
259284
syscall_handler: &mut Self,
260-
remaining_gas: &mut u64,
261-
) -> SyscallResult<SecpNewResponse>;
285+
_remaining_gas: &mut u64,
286+
) -> SyscallResult<Secp256r1NewResponse> {
287+
syscall_handler.get_secpr1_hint_processor().secp_new(vm, request)
288+
}
262289

263290
fn send_message_to_l1(
264291
request: SendMessageToL1Request,

‎crates/starknet_os/src/hint_processor/snos_hint_processor.rs

-1
Original file line numberDiff line numberDiff line change
@@ -301,7 +301,6 @@ impl<'a> SnosHintProcessor<'a, DictStateReader> {
301301
/// Default implementation (required for the VM to use the type as a hint processor).
302302
impl<S: StateReader> ResourceTracker for SnosHintProcessor<'_, S> {}
303303

304-
#[allow(dead_code)]
305304
pub struct SyscallHintProcessor {
306305
// Sha256 segments.
307306
sha256_segment: Option<Relocatable>,

0 commit comments

Comments
 (0)