1use multiversx_chain_vm_executor::{MemLength, MemPtr, VMHooks, VMHooksEarlyExit};
2
3use super::{VMHooksContext, VMHooksHandler};
4
5pub(super) const RESULT_TRUE: i32 = 1;
6pub(super) const RESULT_FALSE: i32 = 0;
7pub(super) const RESULT_OK: i32 = 0;
8pub(super) const RESULT_ERROR: i32 = 1;
9
10#[derive(Debug)]
12pub struct VMHooksDispatcher<C: VMHooksContext> {
13 pub(crate) handler: VMHooksHandler<C>,
14}
15
16impl<C: VMHooksContext> VMHooksDispatcher<C> {
17 pub fn new(vh_context: C) -> Self {
18 VMHooksDispatcher {
19 handler: VMHooksHandler::new(vh_context),
20 }
21 }
22}
23
24fn map_bool_to_i32(result: Result<bool, VMHooksEarlyExit>) -> Result<i32, VMHooksEarlyExit> {
25 result.map(|b| if b { RESULT_TRUE } else { RESULT_FALSE })
26}
27
28#[allow(unused_variables)]
29impl<C: VMHooksContext> VMHooks for VMHooksDispatcher<C> {
30 fn get_gas_left(&mut self) -> Result<i64, VMHooksEarlyExit> {
31 self.handler.get_gas_left()
32 }
33
34 fn get_sc_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
35 panic!("Unavailable: get_sc_address");
36 }
37
38 fn get_owner_address(&mut self, result_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
39 panic!("Unavailable: get_owner_address");
40 }
41
42 fn get_shard_of_address(&mut self, address_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
43 unsafe {
44 let address_bytes = self.handler.context.memory_load(address_offset, 32);
45 self.handler.get_shard_of_address(&address_bytes)
46 }
47 }
48
49 fn is_smart_contract(&mut self, address_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
50 unsafe {
51 let address_bytes = self.handler.context.memory_load(address_offset, 32);
52 map_bool_to_i32(self.handler.is_smart_contract(&address_bytes))
53 }
54 }
55
56 fn signal_error(
57 &mut self,
58 message_offset: MemPtr,
59 message_length: MemLength,
60 ) -> Result<(), VMHooksEarlyExit> {
61 unsafe {
62 let message = self
63 .handler
64 .context
65 .memory_load(message_offset, message_length);
66 self.handler.signal_error(&message)
67 }
68 }
69
70 fn get_external_balance(
71 &mut self,
72 address_offset: MemPtr,
73 result_offset: MemPtr,
74 ) -> Result<(), VMHooksEarlyExit> {
75 panic!("Unavailable: get_external_balance");
76 }
77
78 fn get_block_hash(
79 &mut self,
80 nonce: i64,
81 result_offset: MemPtr,
82 ) -> Result<i32, VMHooksEarlyExit> {
83 panic!("Unavailable: get_block_hash")
84 }
85
86 fn get_esdt_balance(
87 &mut self,
88 address_offset: MemPtr,
89 token_id_offset: MemPtr,
90 token_id_len: MemLength,
91 nonce: i64,
92 result_offset: MemPtr,
93 ) -> Result<i32, VMHooksEarlyExit> {
94 panic!("Unavailable: get_esdt_balance")
95 }
96
97 fn get_esdt_nft_name_length(
98 &mut self,
99 address_offset: MemPtr,
100 token_id_offset: MemPtr,
101 token_id_len: MemLength,
102 nonce: i64,
103 ) -> Result<i32, VMHooksEarlyExit> {
104 panic!("Unavailable: get_esdt_nft_name_length")
105 }
106
107 fn get_esdt_nft_attribute_length(
108 &mut self,
109 address_offset: MemPtr,
110 token_id_offset: MemPtr,
111 token_id_len: MemLength,
112 nonce: i64,
113 ) -> Result<i32, VMHooksEarlyExit> {
114 panic!("Unavailable: get_esdt_nft_attribute_length")
115 }
116
117 fn get_esdt_nft_uri_length(
118 &mut self,
119 address_offset: MemPtr,
120 token_id_offset: MemPtr,
121 token_id_len: MemLength,
122 nonce: i64,
123 ) -> Result<i32, VMHooksEarlyExit> {
124 panic!("Unavailable: get_esdt_nft_uri_length")
125 }
126
127 fn get_esdt_token_data(
128 &mut self,
129 address_offset: MemPtr,
130 token_id_offset: MemPtr,
131 token_id_len: MemLength,
132 nonce: i64,
133 value_handle: i32,
134 properties_offset: MemPtr,
135 hash_offset: MemPtr,
136 name_offset: MemPtr,
137 attributes_offset: MemPtr,
138 creator_offset: MemPtr,
139 royalties_handle: i32,
140 uris_offset: MemPtr,
141 ) -> Result<i32, VMHooksEarlyExit> {
142 panic!("Unavailable: get_esdt_token_data")
143 }
144
145 fn get_esdt_local_roles(&mut self, token_id_handle: i32) -> Result<i64, VMHooksEarlyExit> {
146 self.handler.get_esdt_local_roles_bits(token_id_handle)
147 }
148
149 fn validate_token_identifier(&mut self, token_id_handle: i32) -> Result<i32, VMHooksEarlyExit> {
150 map_bool_to_i32(self.handler.validate_token_identifier(token_id_handle))
151 }
152
153 fn transfer_value(
154 &mut self,
155 dest_offset: MemPtr,
156 value_offset: MemPtr,
157 data_offset: MemPtr,
158 length: MemLength,
159 ) -> Result<i32, VMHooksEarlyExit> {
160 panic!("Unavailable: transfer_value")
161 }
162
163 fn transfer_value_execute(
164 &mut self,
165 dest_offset: MemPtr,
166 value_offset: MemPtr,
167 gas_limit: i64,
168 function_offset: MemPtr,
169 function_length: MemLength,
170 num_arguments: i32,
171 arguments_length_offset: MemPtr,
172 data_offset: MemPtr,
173 ) -> Result<i32, VMHooksEarlyExit> {
174 panic!("Unavailable: transfer_value_execute")
175 }
176
177 fn transfer_esdt_execute(
178 &mut self,
179 dest_offset: MemPtr,
180 token_id_offset: MemPtr,
181 token_id_len: MemLength,
182 value_offset: MemPtr,
183 gas_limit: i64,
184 function_offset: MemPtr,
185 function_length: MemLength,
186 num_arguments: i32,
187 arguments_length_offset: MemPtr,
188 data_offset: MemPtr,
189 ) -> Result<i32, VMHooksEarlyExit> {
190 panic!("Unavailable: transfer_esdt_execute")
191 }
192
193 fn transfer_esdt_nft_execute(
194 &mut self,
195 dest_offset: MemPtr,
196 token_id_offset: MemPtr,
197 token_id_len: MemLength,
198 value_offset: MemPtr,
199 nonce: i64,
200 gas_limit: i64,
201 function_offset: MemPtr,
202 function_length: MemLength,
203 num_arguments: i32,
204 arguments_length_offset: MemPtr,
205 data_offset: MemPtr,
206 ) -> Result<i32, VMHooksEarlyExit> {
207 panic!("Unavailable: transfer_esdt_nft_execute")
208 }
209
210 fn multi_transfer_esdt_nft_execute(
211 &mut self,
212 dest_offset: MemPtr,
213 num_token_transfers: i32,
214 token_transfers_args_length_offset: MemPtr,
215 token_transfer_data_offset: MemPtr,
216 gas_limit: i64,
217 function_offset: MemPtr,
218 function_length: MemLength,
219 num_arguments: i32,
220 arguments_length_offset: MemPtr,
221 data_offset: MemPtr,
222 ) -> Result<i32, VMHooksEarlyExit> {
223 panic!("Unavailable: multi_transfer_esdt_nft_execute")
224 }
225
226 fn create_async_call(
227 &mut self,
228 dest_offset: MemPtr,
229 value_offset: MemPtr,
230 data_offset: MemPtr,
231 data_length: MemLength,
232 success_offset: MemPtr,
233 success_length: MemLength,
234 error_offset: MemPtr,
235 error_length: MemLength,
236 gas: i64,
237 extra_gas_for_callback: i64,
238 ) -> Result<i32, VMHooksEarlyExit> {
239 panic!("Unavailable: create_async_call")
240 }
241
242 fn set_async_context_callback(
243 &mut self,
244 callback: MemPtr,
245 callback_length: MemLength,
246 data: MemPtr,
247 data_length: MemLength,
248 gas: i64,
249 ) -> Result<i32, VMHooksEarlyExit> {
250 panic!("Unavailable: set_async_context_callback")
251 }
252
253 fn upgrade_contract(
254 &mut self,
255 dest_offset: MemPtr,
256 gas_limit: i64,
257 value_offset: MemPtr,
258 code_offset: MemPtr,
259 code_metadata_offset: MemPtr,
260 length: MemLength,
261 num_arguments: i32,
262 arguments_length_offset: MemPtr,
263 data_offset: MemPtr,
264 ) -> Result<(), VMHooksEarlyExit> {
265 panic!("Unavailable: upgrade_contract");
266 }
267
268 fn upgrade_from_source_contract(
269 &mut self,
270 dest_offset: MemPtr,
271 gas_limit: i64,
272 value_offset: MemPtr,
273 source_contract_address_offset: MemPtr,
274 code_metadata_offset: MemPtr,
275 num_arguments: i32,
276 arguments_length_offset: MemPtr,
277 data_offset: MemPtr,
278 ) -> Result<(), VMHooksEarlyExit> {
279 panic!("Unavailable: upgrade_from_source_contract");
280 }
281
282 fn delete_contract(
283 &mut self,
284 dest_offset: MemPtr,
285 gas_limit: i64,
286 num_arguments: i32,
287 arguments_length_offset: MemPtr,
288 data_offset: MemPtr,
289 ) -> Result<(), VMHooksEarlyExit> {
290 panic!("Unavailable: delete_contract");
291 }
292
293 fn async_call(
294 &mut self,
295 dest_offset: MemPtr,
296 value_offset: MemPtr,
297 data_offset: MemPtr,
298 length: MemLength,
299 ) -> Result<(), VMHooksEarlyExit> {
300 panic!("Unavailable: async_call");
301 }
302
303 fn get_argument_length(&mut self, id: i32) -> Result<i32, VMHooksEarlyExit> {
304 self.handler.get_argument_len(id).map(|len| len as i32)
305 }
306
307 fn get_argument(&mut self, id: i32, arg_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
308 panic!("Unavailable: get_argument")
309 }
310
311 fn get_function(&mut self, function_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
312 panic!("Unavailable: get_function")
313 }
314
315 fn get_num_arguments(&mut self) -> Result<i32, VMHooksEarlyExit> {
316 self.handler.get_num_arguments()
317 }
318
319 fn storage_store(
320 &mut self,
321 key_offset: MemPtr,
322 key_length: MemLength,
323 data_offset: MemPtr,
324 data_length: MemLength,
325 ) -> Result<i32, VMHooksEarlyExit> {
326 panic!("Unavailable: storage_store")
327 }
328
329 fn storage_load_length(
330 &mut self,
331 key_offset: MemPtr,
332 key_length: MemLength,
333 ) -> Result<i32, VMHooksEarlyExit> {
334 panic!("Unavailable: storage_load_length")
335 }
336
337 fn storage_load_from_address(
338 &mut self,
339 address_offset: MemPtr,
340 key_offset: MemPtr,
341 key_length: MemLength,
342 data_offset: MemPtr,
343 ) -> Result<i32, VMHooksEarlyExit> {
344 panic!("Unavailable: storage_load_from_address")
345 }
346
347 fn storage_load(
348 &mut self,
349 key_offset: MemPtr,
350 key_length: MemLength,
351 data_offset: MemPtr,
352 ) -> Result<i32, VMHooksEarlyExit> {
353 panic!("Unavailable: storage_load")
354 }
355
356 fn set_storage_lock(
357 &mut self,
358 key_offset: MemPtr,
359 key_length: MemLength,
360 lock_timestamp: i64,
361 ) -> Result<i32, VMHooksEarlyExit> {
362 panic!("Unavailable: set_storage_lock")
363 }
364
365 fn get_storage_lock(
366 &mut self,
367 key_offset: MemPtr,
368 key_length: MemLength,
369 ) -> Result<i64, VMHooksEarlyExit> {
370 panic!("Unavailable: get_storage_lock")
371 }
372
373 fn is_storage_locked(
374 &mut self,
375 key_offset: MemPtr,
376 key_length: MemLength,
377 ) -> Result<i32, VMHooksEarlyExit> {
378 panic!("Unavailable: is_storage_locked")
379 }
380
381 fn clear_storage_lock(
382 &mut self,
383 key_offset: MemPtr,
384 key_length: MemLength,
385 ) -> Result<i32, VMHooksEarlyExit> {
386 panic!("Unavailable: clear_storage_lock")
387 }
388
389 fn get_caller(&mut self, result_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
390 panic!("Unavailable: get_caller");
391 }
392
393 fn check_no_payment(&mut self) -> Result<(), VMHooksEarlyExit> {
394 self.handler.check_not_payable()
395 }
396
397 fn get_call_value(&mut self, result_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
398 panic!("Unavailable: get_call_value")
399 }
400
401 fn get_esdt_value(&mut self, result_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
402 panic!("Unavailable: get_esdt_value")
403 }
404
405 fn get_esdt_value_by_index(
406 &mut self,
407 result_offset: MemPtr,
408 index: i32,
409 ) -> Result<i32, VMHooksEarlyExit> {
410 panic!("Unavailable: get_esdt_value_by_index")
411 }
412
413 fn get_esdt_token_name(&mut self, result_offset: MemPtr) -> Result<i32, VMHooksEarlyExit> {
414 panic!("Unavailable: get_esdt_token_name")
415 }
416
417 fn get_esdt_token_name_by_index(
418 &mut self,
419 result_offset: MemPtr,
420 index: i32,
421 ) -> Result<i32, VMHooksEarlyExit> {
422 panic!("Unavailable: get_esdt_token_name_by_index")
423 }
424
425 fn get_esdt_token_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
426 panic!("Unavailable: get_esdt_token_nonce")
427 }
428
429 fn get_esdt_token_nonce_by_index(&mut self, index: i32) -> Result<i64, VMHooksEarlyExit> {
430 panic!("Unavailable: get_esdt_token_nonce_by_index")
431 }
432
433 fn get_current_esdt_nft_nonce(
434 &mut self,
435 address_offset: MemPtr,
436 token_id_offset: MemPtr,
437 token_id_len: MemLength,
438 ) -> Result<i64, VMHooksEarlyExit> {
439 unsafe {
440 let address_bytes = self.handler.context.memory_load(address_offset, 32);
441 let token_id_bytes = self
442 .handler
443 .context
444 .memory_load(token_id_offset, token_id_len);
445 self.handler
446 .get_current_esdt_nft_nonce(&address_bytes, &token_id_bytes)
447 }
448 }
449
450 fn get_esdt_token_type(&mut self) -> Result<i32, VMHooksEarlyExit> {
451 panic!("Unavailable: get_esdt_token_type")
452 }
453
454 fn get_esdt_token_type_by_index(&mut self, index: i32) -> Result<i32, VMHooksEarlyExit> {
455 panic!("Unavailable: get_esdt_token_type_by_index")
456 }
457
458 fn get_num_esdt_transfers(&mut self) -> Result<i32, VMHooksEarlyExit> {
459 Ok(self.handler.esdt_num_transfers() as i32)
460 }
461
462 fn get_call_value_token_name(
463 &mut self,
464 call_value_offset: MemPtr,
465 token_name_offset: MemPtr,
466 ) -> Result<i32, VMHooksEarlyExit> {
467 panic!("Unavailable: get_call_value_token_name")
468 }
469
470 fn get_call_value_token_name_by_index(
471 &mut self,
472 call_value_offset: MemPtr,
473 token_name_offset: MemPtr,
474 index: i32,
475 ) -> Result<i32, VMHooksEarlyExit> {
476 panic!("Unavailable: get_call_value_token_name_by_index")
477 }
478
479 fn write_log(
480 &mut self,
481 data_pointer: MemPtr,
482 data_length: MemLength,
483 topic_ptr: MemPtr,
484 num_topics: i32,
485 ) -> Result<(), VMHooksEarlyExit> {
486 panic!("Unavailable: write_log");
487 }
488
489 fn write_event_log(
490 &mut self,
491 num_topics: i32,
492 topic_lengths_offset: MemPtr,
493 topic_offset: MemPtr,
494 data_offset: MemPtr,
495 data_length: MemLength,
496 ) -> Result<(), VMHooksEarlyExit> {
497 panic!("Unavailable: write_event_log");
498 }
499
500 fn get_block_timestamp(&mut self) -> Result<i64, VMHooksEarlyExit> {
501 self.handler.get_block_timestamp()
502 }
503
504 fn get_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
505 self.handler.get_block_timestamp_ms()
506 }
507
508 fn get_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
509 self.handler.get_block_nonce()
510 }
511
512 fn get_block_round(&mut self) -> Result<i64, VMHooksEarlyExit> {
513 self.handler.get_block_round()
514 }
515
516 fn get_block_epoch(&mut self) -> Result<i64, VMHooksEarlyExit> {
517 self.handler.get_block_epoch()
518 }
519
520 fn get_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksEarlyExit> {
521 panic!("Unavailable: get_block_random_seed");
522 }
523
524 fn get_state_root_hash(&mut self, pointer: MemPtr) -> Result<(), VMHooksEarlyExit> {
525 panic!("Unavailable: get_state_root_hash");
526 }
527
528 fn get_prev_block_timestamp(&mut self) -> Result<i64, VMHooksEarlyExit> {
529 self.handler.get_prev_block_timestamp()
530 }
531
532 fn get_prev_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
533 self.handler.get_prev_block_timestamp_ms()
534 }
535
536 fn get_prev_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
537 self.handler.get_prev_block_nonce()
538 }
539
540 fn get_prev_block_round(&mut self) -> Result<i64, VMHooksEarlyExit> {
541 self.handler.get_prev_block_round()
542 }
543
544 fn get_prev_block_epoch(&mut self) -> Result<i64, VMHooksEarlyExit> {
545 self.handler.get_prev_block_epoch()
546 }
547
548 fn get_prev_block_random_seed(&mut self, pointer: MemPtr) -> Result<(), VMHooksEarlyExit> {
549 panic!("Unavailable: get_prev_block_random_seed");
550 }
551
552 fn finish(&mut self, pointer: MemPtr, length: MemLength) -> Result<(), VMHooksEarlyExit> {
553 unsafe {
554 let bytes = self.handler.context.memory_load(pointer, length);
555 self.handler.finish_slice_u8(&bytes)
556 }
557 }
558
559 fn execute_on_same_context(
560 &mut self,
561 gas_limit: i64,
562 address_offset: MemPtr,
563 value_offset: MemPtr,
564 function_offset: MemPtr,
565 function_length: MemLength,
566 num_arguments: i32,
567 arguments_length_offset: MemPtr,
568 data_offset: MemPtr,
569 ) -> Result<i32, VMHooksEarlyExit> {
570 panic!("Unavailable: execute_on_same_context")
571 }
572
573 fn execute_on_dest_context(
574 &mut self,
575 gas_limit: i64,
576 address_offset: MemPtr,
577 value_offset: MemPtr,
578 function_offset: MemPtr,
579 function_length: MemLength,
580 num_arguments: i32,
581 arguments_length_offset: MemPtr,
582 data_offset: MemPtr,
583 ) -> Result<i32, VMHooksEarlyExit> {
584 panic!("Unavailable: execute_on_dest_context")
585 }
586
587 fn execute_read_only(
588 &mut self,
589 gas_limit: i64,
590 address_offset: MemPtr,
591 function_offset: MemPtr,
592 function_length: MemLength,
593 num_arguments: i32,
594 arguments_length_offset: MemPtr,
595 data_offset: MemPtr,
596 ) -> Result<i32, VMHooksEarlyExit> {
597 panic!("Unavailable: execute_read_only")
598 }
599
600 fn create_contract(
601 &mut self,
602 gas_limit: i64,
603 value_offset: MemPtr,
604 code_offset: MemPtr,
605 code_metadata_offset: MemPtr,
606 length: MemLength,
607 result_offset: MemPtr,
608 num_arguments: i32,
609 arguments_length_offset: MemPtr,
610 data_offset: MemPtr,
611 ) -> Result<i32, VMHooksEarlyExit> {
612 panic!("Unavailable: create_contract")
613 }
614
615 fn deploy_from_source_contract(
616 &mut self,
617 gas_limit: i64,
618 value_offset: MemPtr,
619 source_contract_address_offset: MemPtr,
620 code_metadata_offset: MemPtr,
621 result_address_offset: MemPtr,
622 num_arguments: i32,
623 arguments_length_offset: MemPtr,
624 data_offset: MemPtr,
625 ) -> Result<i32, VMHooksEarlyExit> {
626 panic!("Unavailable: deploy_from_source_contract")
627 }
628
629 fn get_num_return_data(&mut self) -> Result<i32, VMHooksEarlyExit> {
630 panic!("Unavailable: get_num_return_data")
631 }
632
633 fn get_return_data_size(&mut self, result_id: i32) -> Result<i32, VMHooksEarlyExit> {
634 panic!("Unavailable: get_return_data_size")
635 }
636
637 fn get_return_data(
638 &mut self,
639 result_id: i32,
640 data_offset: MemPtr,
641 ) -> Result<i32, VMHooksEarlyExit> {
642 panic!("Unavailable: get_return_data")
643 }
644
645 fn clean_return_data(&mut self) -> Result<(), VMHooksEarlyExit> {
646 self.handler.clean_return_data()
647 }
648
649 fn delete_from_return_data(&mut self, result_id: i32) -> Result<(), VMHooksEarlyExit> {
650 self.handler.delete_from_return_data(result_id as usize)
651 }
652
653 fn get_original_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
654 panic!("Unavailable: get_original_tx_hash");
655 }
656
657 fn get_current_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
658 panic!("Unavailable: get_current_tx_hash");
659 }
660
661 fn get_prev_tx_hash(&mut self, data_offset: MemPtr) -> Result<(), VMHooksEarlyExit> {
662 panic!("Unavailable: get_prev_tx_hash");
663 }
664
665 fn managed_sc_address(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
666 self.handler.managed_sc_address(destination_handle)
667 }
668
669 fn managed_owner_address(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
670 self.handler.managed_owner_address(destination_handle)
671 }
672
673 fn managed_caller(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
674 self.handler.managed_caller(destination_handle)
675 }
676
677 fn managed_signal_error(&mut self, err_handle: i32) -> Result<(), VMHooksEarlyExit> {
678 self.handler.signal_error_from_buffer(err_handle)
679 }
680
681 fn managed_write_log(
682 &mut self,
683 topics_handle: i32,
684 data_handle: i32,
685 ) -> Result<(), VMHooksEarlyExit> {
686 self.handler.managed_write_log(topics_handle, data_handle)
687 }
688
689 fn managed_get_original_tx_hash(&mut self, result_handle: i32) -> Result<(), VMHooksEarlyExit> {
690 self.handler.get_tx_hash(result_handle)
691 }
692
693 fn managed_get_state_root_hash(&mut self, result_handle: i32) -> Result<(), VMHooksEarlyExit> {
694 panic!("Unavailable: managed_get_state_root_hash");
695 }
696
697 fn managed_get_block_random_seed(
698 &mut self,
699 result_handle: i32,
700 ) -> Result<(), VMHooksEarlyExit> {
701 self.handler.get_block_random_seed(result_handle)
702 }
703
704 fn managed_get_prev_block_random_seed(
705 &mut self,
706 result_handle: i32,
707 ) -> Result<(), VMHooksEarlyExit> {
708 self.handler.get_prev_block_random_seed(result_handle)
709 }
710
711 fn get_block_round_time_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
712 self.handler.get_block_round_time_ms()
713 }
714
715 fn epoch_start_block_timestamp_ms(&mut self) -> Result<i64, VMHooksEarlyExit> {
716 self.handler.get_epoch_start_block_timestamp_ms()
717 }
718
719 fn epoch_start_block_nonce(&mut self) -> Result<i64, VMHooksEarlyExit> {
720 self.handler.get_epoch_start_block_nonce()
721 }
722
723 fn epoch_start_block_round(&mut self) -> Result<i64, VMHooksEarlyExit> {
724 self.handler.get_epoch_start_block_round()
725 }
726
727 fn managed_get_return_data(
728 &mut self,
729 result_id: i32,
730 result_handle: i32,
731 ) -> Result<(), VMHooksEarlyExit> {
732 panic!("Unavailable: managed_get_return_data");
733 }
734
735 fn managed_get_all_transfers_call_value(
736 &mut self,
737 all_transfers_handle: i32,
738 ) -> Result<(), VMHooksEarlyExit> {
739 self.handler.load_all_transfers(all_transfers_handle)
740 }
741
742 fn managed_get_multi_esdt_call_value(
743 &mut self,
744 multi_call_value_handle: i32,
745 ) -> Result<(), VMHooksEarlyExit> {
746 self.handler
747 .load_all_esdt_transfers(multi_call_value_handle)
748 }
749
750 fn managed_get_esdt_balance(
751 &mut self,
752 address_handle: i32,
753 token_id_handle: i32,
754 nonce: i64,
755 value_handle: i32,
756 ) -> Result<(), VMHooksEarlyExit> {
757 panic!("Unavailable: managed_get_esdt_balance");
758 }
759
760 fn managed_get_esdt_token_data(
761 &mut self,
762 address_handle: i32,
763 token_id_handle: i32,
764 nonce: i64,
765 value_handle: i32,
766 properties_handle: i32,
767 hash_handle: i32,
768 name_handle: i32,
769 attributes_handle: i32,
770 creator_handle: i32,
771 royalties_handle: i32,
772 uris_handle: i32,
773 ) -> Result<(), VMHooksEarlyExit> {
774 self.handler.managed_get_esdt_token_data(
775 address_handle,
776 token_id_handle,
777 nonce as u64,
778 value_handle,
779 properties_handle,
780 hash_handle,
781 name_handle,
782 attributes_handle,
783 creator_handle,
784 royalties_handle,
785 uris_handle,
786 )
787 }
788
789 fn managed_get_esdt_token_type(
790 &mut self,
791 address_handle: i32,
792 token_id_handle: i32,
793 nonce: i64,
794 type_handle: i32,
795 ) -> Result<(), VMHooksEarlyExit> {
796 self.handler.managed_get_esdt_token_type(
797 address_handle,
798 token_id_handle,
799 nonce,
800 type_handle,
801 )
802 }
803
804 fn managed_get_back_transfers(
805 &mut self,
806 esdt_transfer_value_handle: i32,
807 call_value_handle: i32,
808 ) -> Result<(), VMHooksEarlyExit> {
809 self.handler
810 .managed_get_back_transfers(esdt_transfer_value_handle, call_value_handle)
811 }
812
813 fn managed_async_call(
814 &mut self,
815 dest_handle: i32,
816 value_handle: i32,
817 function_handle: i32,
818 arguments_handle: i32,
819 ) -> Result<(), VMHooksEarlyExit> {
820 self.handler
821 .async_call_raw(dest_handle, value_handle, function_handle, arguments_handle)
822 }
823
824 fn managed_create_async_call(
825 &mut self,
826 dest_handle: i32,
827 value_handle: i32,
828 function_handle: i32,
829 arguments_handle: i32,
830 success_offset: MemPtr,
831 success_length: MemLength,
832 error_offset: MemPtr,
833 error_length: MemLength,
834 gas: i64,
835 extra_gas_for_callback: i64,
836 callback_closure_handle: i32,
837 ) -> Result<i32, VMHooksEarlyExit> {
838 unsafe {
839 let success_callback = self
840 .handler
841 .context
842 .memory_load(success_offset, success_length);
843 let error_callback = self.handler.context.memory_load(error_offset, error_length);
844 self.handler.create_async_call_raw(
845 dest_handle,
846 value_handle,
847 function_handle,
848 arguments_handle,
849 &success_callback,
850 &error_callback,
851 gas as u64,
852 extra_gas_for_callback as u64,
853 callback_closure_handle,
854 )?;
855 }
856 Ok(RESULT_OK)
857 }
858
859 fn managed_get_callback_closure(
860 &mut self,
861 callback_closure_handle: i32,
862 ) -> Result<(), VMHooksEarlyExit> {
863 self.handler
864 .load_callback_closure_buffer(callback_closure_handle)
865 }
866
867 fn managed_upgrade_from_source_contract(
868 &mut self,
869 dest_handle: i32,
870 gas: i64,
871 value_handle: i32,
872 address_handle: i32,
873 code_metadata_handle: i32,
874 arguments_handle: i32,
875 _result_handle: i32,
876 ) -> Result<(), VMHooksEarlyExit> {
877 self.handler.upgrade_from_source_contract(
878 dest_handle,
879 gas as u64,
880 value_handle,
881 address_handle,
882 code_metadata_handle,
883 arguments_handle,
884 )
885 }
886
887 fn managed_upgrade_contract(
888 &mut self,
889 dest_handle: i32,
890 gas: i64,
891 value_handle: i32,
892 code_handle: i32,
893 code_metadata_handle: i32,
894 arguments_handle: i32,
895 _result_handle: i32,
896 ) -> Result<(), VMHooksEarlyExit> {
897 self.handler.upgrade_contract(
898 dest_handle,
899 gas as u64,
900 value_handle,
901 code_handle,
902 code_metadata_handle,
903 arguments_handle,
904 )
905 }
906
907 fn managed_delete_contract(
908 &mut self,
909 dest_handle: i32,
910 gas_limit: i64,
911 arguments_handle: i32,
912 ) -> Result<(), VMHooksEarlyExit> {
913 panic!("Unavailable: managed_delete_contract");
914 }
915
916 fn managed_deploy_from_source_contract(
917 &mut self,
918 gas: i64,
919 value_handle: i32,
920 address_handle: i32,
921 code_metadata_handle: i32,
922 arguments_handle: i32,
923 result_address_handle: i32,
924 result_handle: i32,
925 ) -> Result<i32, VMHooksEarlyExit> {
926 self.handler.deploy_from_source_contract(
927 gas as u64,
928 value_handle,
929 address_handle,
930 code_metadata_handle,
931 arguments_handle,
932 result_address_handle,
933 result_handle,
934 )?;
935 Ok(RESULT_OK)
936 }
937
938 fn managed_create_contract(
939 &mut self,
940 gas: i64,
941 value_handle: i32,
942 code_handle: i32,
943 code_metadata_handle: i32,
944 arguments_handle: i32,
945 result_address_handle: i32,
946 result_handle: i32,
947 ) -> Result<i32, VMHooksEarlyExit> {
948 self.handler.deploy_contract(
949 gas as u64,
950 value_handle,
951 code_handle,
952 code_metadata_handle,
953 arguments_handle,
954 result_address_handle,
955 result_handle,
956 )?;
957 Ok(RESULT_OK)
958 }
959
960 fn managed_execute_read_only(
961 &mut self,
962 gas: i64,
963 address_handle: i32,
964 function_handle: i32,
965 arguments_handle: i32,
966 result_handle: i32,
967 ) -> Result<i32, VMHooksEarlyExit> {
968 self.handler.execute_on_dest_context_readonly_raw(
969 gas as u64,
970 address_handle,
971 function_handle,
972 arguments_handle,
973 result_handle,
974 )?;
975 Ok(RESULT_OK)
976 }
977
978 fn managed_execute_on_same_context(
979 &mut self,
980 gas: i64,
981 address_handle: i32,
982 value_handle: i32,
983 function_handle: i32,
984 arguments_handle: i32,
985 result_handle: i32,
986 ) -> Result<i32, VMHooksEarlyExit> {
987 panic!("Unavailable: managed_execute_on_same_context")
988 }
989
990 fn managed_execute_on_dest_context(
991 &mut self,
992 gas: i64,
993 address_handle: i32,
994 value_handle: i32,
995 function_handle: i32,
996 arguments_handle: i32,
997 result_handle: i32,
998 ) -> Result<i32, VMHooksEarlyExit> {
999 self.handler.execute_on_dest_context_raw(
1000 gas as u64,
1001 address_handle,
1002 value_handle,
1003 function_handle,
1004 arguments_handle,
1005 result_handle,
1006 )?;
1007 Ok(RESULT_OK)
1008 }
1009
1010 fn managed_execute_on_dest_context_with_error_return(
1011 &mut self,
1012 gas: i64,
1013 address_handle: i32,
1014 value_handle: i32,
1015 function_handle: i32,
1016 arguments_handle: i32,
1017 result_handle: i32,
1018 ) -> Result<i32, VMHooksEarlyExit> {
1019 self.handler.execute_on_dest_context_fallible(
1020 gas as u64,
1021 address_handle,
1022 value_handle,
1023 function_handle,
1024 arguments_handle,
1025 result_handle,
1026 )
1027 }
1028
1029 fn managed_multi_transfer_esdt_nft_execute(
1030 &mut self,
1031 dst_handle: i32,
1032 token_transfers_handle: i32,
1033 gas_limit: i64,
1034 function_handle: i32,
1035 arguments_handle: i32,
1036 ) -> Result<i32, VMHooksEarlyExit> {
1037 self.handler.multi_transfer_esdt_nft_execute(
1038 dst_handle,
1039 token_transfers_handle,
1040 gas_limit as u64,
1041 function_handle,
1042 arguments_handle,
1043 )?;
1044 Ok(RESULT_OK)
1045 }
1046
1047 fn managed_multi_transfer_esdt_nft_execute_with_return(
1048 &mut self,
1049 dst_handle: i32,
1050 token_transfers_handle: i32,
1051 gas_limit: i64,
1052 function_handle: i32,
1053 arguments_handle: i32,
1054 ) -> Result<i32, VMHooksEarlyExit> {
1055 self.handler
1056 .managed_multi_transfer_esdt_nft_execute_with_return(
1057 dst_handle,
1058 token_transfers_handle,
1059 gas_limit as u64,
1060 function_handle,
1061 arguments_handle,
1062 )
1063 }
1064
1065 fn managed_transfer_value_execute(
1066 &mut self,
1067 dst_handle: i32,
1068 value_handle: i32,
1069 gas_limit: i64,
1070 function_handle: i32,
1071 arguments_handle: i32,
1072 ) -> Result<i32, VMHooksEarlyExit> {
1073 self.handler.transfer_value_execute(
1074 dst_handle,
1075 value_handle,
1076 gas_limit as u64,
1077 function_handle,
1078 arguments_handle,
1079 )?;
1080 Ok(RESULT_OK)
1081 }
1082
1083 fn managed_is_esdt_frozen(
1084 &mut self,
1085 address_handle: i32,
1086 token_id_handle: i32,
1087 nonce: i64,
1088 ) -> Result<i32, VMHooksEarlyExit> {
1089 map_bool_to_i32(self.handler.check_esdt_frozen(
1090 address_handle,
1091 token_id_handle,
1092 nonce as u64,
1093 ))
1094 }
1095
1096 fn managed_is_esdt_limited_transfer(
1097 &mut self,
1098 _token_id_handle: i32,
1099 ) -> Result<i32, VMHooksEarlyExit> {
1100 map_bool_to_i32(Ok(false))
1101 }
1102
1103 fn managed_is_esdt_paused(&mut self, _token_id_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1104 map_bool_to_i32(Ok(false))
1105 }
1106
1107 fn managed_buffer_to_hex(
1108 &mut self,
1109 source_handle: i32,
1110 dest_handle: i32,
1111 ) -> Result<(), VMHooksEarlyExit> {
1112 self.handler.mb_to_hex(source_handle, dest_handle)
1113 }
1114
1115 fn managed_get_code_metadata(
1116 &mut self,
1117 address_handle: i32,
1118 response_handle: i32,
1119 ) -> Result<(), VMHooksEarlyExit> {
1120 self.handler
1121 .managed_get_code_metadata(address_handle, response_handle)
1122 }
1123
1124 fn managed_get_code_hash(
1125 &mut self,
1126 address_handle: i32,
1127 code_hash_handle: i32,
1128 ) -> Result<(), VMHooksEarlyExit> {
1129 panic!("Unavailable: managed_get_code_hash")
1130 }
1131
1132 fn managed_is_builtin_function(
1133 &mut self,
1134 function_name_handle: i32,
1135 ) -> Result<i32, VMHooksEarlyExit> {
1136 map_bool_to_i32(
1137 self.handler
1138 .managed_is_builtin_function(function_name_handle),
1139 )
1140 }
1141
1142 fn big_float_new_from_parts(
1143 &mut self,
1144 integral_part: i32,
1145 fractional_part: i32,
1146 exponent: i32,
1147 ) -> Result<i32, VMHooksEarlyExit> {
1148 self.handler
1149 .bf_from_parts(integral_part, fractional_part, exponent)
1150 }
1151
1152 fn big_float_new_from_frac(
1153 &mut self,
1154 numerator: i64,
1155 denominator: i64,
1156 ) -> Result<i32, VMHooksEarlyExit> {
1157 self.handler.bf_from_frac(numerator, denominator)
1158 }
1159
1160 fn big_float_new_from_sci(
1161 &mut self,
1162 significand: i64,
1163 exponent: i64,
1164 ) -> Result<i32, VMHooksEarlyExit> {
1165 self.handler.bf_from_sci(significand, exponent)
1166 }
1167
1168 fn big_float_add(
1169 &mut self,
1170 destination_handle: i32,
1171 op1_handle: i32,
1172 op2_handle: i32,
1173 ) -> Result<(), VMHooksEarlyExit> {
1174 self.handler
1175 .bf_add(destination_handle, op1_handle, op2_handle)
1176 }
1177
1178 fn big_float_sub(
1179 &mut self,
1180 destination_handle: i32,
1181 op1_handle: i32,
1182 op2_handle: i32,
1183 ) -> Result<(), VMHooksEarlyExit> {
1184 self.handler
1185 .bf_sub(destination_handle, op1_handle, op2_handle)
1186 }
1187
1188 fn big_float_mul(
1189 &mut self,
1190 destination_handle: i32,
1191 op1_handle: i32,
1192 op2_handle: i32,
1193 ) -> Result<(), VMHooksEarlyExit> {
1194 self.handler
1195 .bf_mul(destination_handle, op1_handle, op2_handle)
1196 }
1197
1198 fn big_float_div(
1199 &mut self,
1200 destination_handle: i32,
1201 op1_handle: i32,
1202 op2_handle: i32,
1203 ) -> Result<(), VMHooksEarlyExit> {
1204 self.handler
1205 .bf_div(destination_handle, op1_handle, op2_handle)
1206 }
1207
1208 fn big_float_neg(
1209 &mut self,
1210 destination_handle: i32,
1211 op_handle: i32,
1212 ) -> Result<(), VMHooksEarlyExit> {
1213 self.handler.bf_neg(destination_handle, op_handle)
1214 }
1215
1216 fn big_float_clone(
1217 &mut self,
1218 destination_handle: i32,
1219 op_handle: i32,
1220 ) -> Result<(), VMHooksEarlyExit> {
1221 self.handler.bf_clone(destination_handle, op_handle)
1222 }
1223
1224 fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1225 self.handler.bf_cmp(op1_handle, op2_handle)
1226 }
1227
1228 fn big_float_abs(
1229 &mut self,
1230 destination_handle: i32,
1231 op_handle: i32,
1232 ) -> Result<(), VMHooksEarlyExit> {
1233 self.handler.bf_abs(destination_handle, op_handle)
1234 }
1235
1236 fn big_float_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1237 self.handler.bf_sign(op_handle)
1238 }
1239
1240 fn big_float_sqrt(
1241 &mut self,
1242 destination_handle: i32,
1243 op_handle: i32,
1244 ) -> Result<(), VMHooksEarlyExit> {
1245 self.handler.bf_sqrt(destination_handle, op_handle)
1246 }
1247
1248 fn big_float_pow(
1249 &mut self,
1250 destination_handle: i32,
1251 op_handle: i32,
1252 exponent: i32,
1253 ) -> Result<(), VMHooksEarlyExit> {
1254 self.handler.bf_pow(destination_handle, op_handle, exponent)
1255 }
1256
1257 fn big_float_floor(
1258 &mut self,
1259 dest_big_int_handle: i32,
1260 op_handle: i32,
1261 ) -> Result<(), VMHooksEarlyExit> {
1262 self.handler.bf_floor(dest_big_int_handle, op_handle)
1263 }
1264
1265 fn big_float_ceil(
1266 &mut self,
1267 dest_big_int_handle: i32,
1268 op_handle: i32,
1269 ) -> Result<(), VMHooksEarlyExit> {
1270 self.handler.bf_ceil(dest_big_int_handle, op_handle)
1271 }
1272
1273 fn big_float_truncate(
1274 &mut self,
1275 dest_big_int_handle: i32,
1276 op_handle: i32,
1277 ) -> Result<(), VMHooksEarlyExit> {
1278 self.handler.bf_trunc(dest_big_int_handle, op_handle)
1279 }
1280
1281 fn big_float_set_int64(
1282 &mut self,
1283 destination_handle: i32,
1284 value: i64,
1285 ) -> Result<(), VMHooksEarlyExit> {
1286 self.handler.bf_set_i64(destination_handle, value)
1287 }
1288
1289 fn big_float_is_int(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1290 map_bool_to_i32(self.handler.bf_is_bi(op_handle))
1291 }
1292
1293 fn big_float_set_big_int(
1294 &mut self,
1295 destination_handle: i32,
1296 big_int_handle: i32,
1297 ) -> Result<(), VMHooksEarlyExit> {
1298 self.handler.bf_set_bi(destination_handle, big_int_handle)
1299 }
1300
1301 fn big_float_get_const_pi(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1302 self.handler.bf_get_const_pi(destination_handle)
1303 }
1304
1305 fn big_float_get_const_e(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1306 self.handler.bf_get_const_e(destination_handle)
1307 }
1308
1309 fn big_int_get_unsigned_argument(
1310 &mut self,
1311 id: i32,
1312 destination_handle: i32,
1313 ) -> Result<(), VMHooksEarlyExit> {
1314 self.handler
1315 .load_argument_big_int_unsigned(id, destination_handle)
1316 }
1317
1318 fn big_int_get_signed_argument(
1319 &mut self,
1320 id: i32,
1321 destination_handle: i32,
1322 ) -> Result<(), VMHooksEarlyExit> {
1323 self.handler
1324 .load_argument_big_int_signed(id, destination_handle)
1325 }
1326
1327 fn big_int_storage_store_unsigned(
1328 &mut self,
1329 key_offset: MemPtr,
1330 key_length: MemLength,
1331 source_handle: i32,
1332 ) -> Result<i32, VMHooksEarlyExit> {
1333 panic!("Unavailable: big_int_storage_store_unsigned")
1334 }
1335
1336 fn big_int_storage_load_unsigned(
1337 &mut self,
1338 key_offset: MemPtr,
1339 key_length: MemLength,
1340 destination_handle: i32,
1341 ) -> Result<i32, VMHooksEarlyExit> {
1342 panic!("Unavailable: big_int_storage_load_unsigned")
1343 }
1344
1345 fn big_int_get_call_value(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1346 self.handler.load_egld_value(destination_handle)
1347 }
1348
1349 fn big_int_get_esdt_call_value(&mut self, destination: i32) -> Result<(), VMHooksEarlyExit> {
1350 panic!("Unavailable: big_int_get_esdt_call_value");
1351 }
1352
1353 fn big_int_get_esdt_call_value_by_index(
1354 &mut self,
1355 destination_handle: i32,
1356 index: i32,
1357 ) -> Result<(), VMHooksEarlyExit> {
1358 panic!("Unavailable: big_int_get_esdt_call_value_by_index");
1359 }
1360
1361 fn big_int_get_external_balance(
1362 &mut self,
1363 address_offset: MemPtr,
1364 result: i32,
1365 ) -> Result<(), VMHooksEarlyExit> {
1366 unsafe {
1367 let address_bytes = self.handler.context.memory_load(address_offset, 32);
1368 self.handler.load_balance(&address_bytes, result)
1369 }
1370 }
1371
1372 fn big_int_get_esdt_external_balance(
1373 &mut self,
1374 address_offset: MemPtr,
1375 token_id_offset: MemPtr,
1376 token_id_len: MemLength,
1377 nonce: i64,
1378 result_handle: i32,
1379 ) -> Result<(), VMHooksEarlyExit> {
1380 unsafe {
1381 let address_bytes = self.handler.context.memory_load(address_offset, 32);
1382 let token_id_bytes = self
1383 .handler
1384 .context
1385 .memory_load(token_id_offset, token_id_len);
1386 self.handler.big_int_get_esdt_external_balance(
1387 &address_bytes,
1388 &token_id_bytes,
1389 nonce as u64,
1390 result_handle,
1391 )
1392 }
1393 }
1394
1395 fn big_int_new(&mut self, small_value: i64) -> Result<i32, VMHooksEarlyExit> {
1396 self.handler.bi_new(small_value)
1397 }
1398
1399 fn big_int_unsigned_byte_length(
1400 &mut self,
1401 reference_handle: i32,
1402 ) -> Result<i32, VMHooksEarlyExit> {
1403 panic!("Unavailable: big_int_unsigned_byte_length")
1404 }
1405
1406 fn big_int_signed_byte_length(
1407 &mut self,
1408 reference_handle: i32,
1409 ) -> Result<i32, VMHooksEarlyExit> {
1410 panic!("Unavailable: big_int_signed_byte_length")
1411 }
1412
1413 fn big_int_get_unsigned_bytes(
1414 &mut self,
1415 reference_handle: i32,
1416 byte_offset: MemPtr,
1417 ) -> Result<i32, VMHooksEarlyExit> {
1418 panic!("Unavailable: big_int_get_unsigned_bytes")
1419 }
1420
1421 fn big_int_get_signed_bytes(
1422 &mut self,
1423 reference_handle: i32,
1424 byte_offset: MemPtr,
1425 ) -> Result<i32, VMHooksEarlyExit> {
1426 panic!("Unavailable: big_int_get_signed_bytes")
1427 }
1428
1429 fn big_int_set_unsigned_bytes(
1430 &mut self,
1431 destination_handle: i32,
1432 byte_offset: MemPtr,
1433 byte_length: MemLength,
1434 ) -> Result<(), VMHooksEarlyExit> {
1435 unsafe {
1436 let bytes = self.handler.context.memory_load(byte_offset, byte_length);
1437 self.handler
1438 .bi_set_unsigned_bytes(destination_handle, &bytes)
1439 }
1440 }
1441
1442 fn big_int_set_signed_bytes(
1443 &mut self,
1444 destination_handle: i32,
1445 byte_offset: MemPtr,
1446 byte_length: MemLength,
1447 ) -> Result<(), VMHooksEarlyExit> {
1448 unsafe {
1449 let bytes = self.handler.context.memory_load(byte_offset, byte_length);
1450 self.handler.bi_set_signed_bytes(destination_handle, &bytes)
1451 }
1452 }
1453
1454 fn big_int_is_int64(&mut self, destination_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1455 self.handler.bi_is_int64(destination_handle)
1456 }
1457
1458 fn big_int_get_int64(&mut self, destination_handle: i32) -> Result<i64, VMHooksEarlyExit> {
1459 self.handler.bi_get_int64(destination_handle)
1460 }
1461
1462 fn big_int_set_int64(
1463 &mut self,
1464 destination_handle: i32,
1465 value: i64,
1466 ) -> Result<(), VMHooksEarlyExit> {
1467 self.handler.bi_set_int64(destination_handle, value)
1468 }
1469
1470 fn big_int_add(
1471 &mut self,
1472 destination_handle: i32,
1473 op1_handle: i32,
1474 op2_handle: i32,
1475 ) -> Result<(), VMHooksEarlyExit> {
1476 self.handler
1477 .bi_add(destination_handle, op1_handle, op2_handle)
1478 }
1479
1480 fn big_int_sub(
1481 &mut self,
1482 destination_handle: i32,
1483 op1_handle: i32,
1484 op2_handle: i32,
1485 ) -> Result<(), VMHooksEarlyExit> {
1486 self.handler
1487 .bi_sub(destination_handle, op1_handle, op2_handle)
1488 }
1489
1490 fn big_int_mul(
1491 &mut self,
1492 destination_handle: i32,
1493 op1_handle: i32,
1494 op2_handle: i32,
1495 ) -> Result<(), VMHooksEarlyExit> {
1496 self.handler
1497 .bi_mul(destination_handle, op1_handle, op2_handle)
1498 }
1499
1500 fn big_int_tdiv(
1501 &mut self,
1502 destination_handle: i32,
1503 op1_handle: i32,
1504 op2_handle: i32,
1505 ) -> Result<(), VMHooksEarlyExit> {
1506 self.handler
1507 .bi_t_div(destination_handle, op1_handle, op2_handle)
1508 }
1509
1510 fn big_int_tmod(
1511 &mut self,
1512 destination_handle: i32,
1513 op1_handle: i32,
1514 op2_handle: i32,
1515 ) -> Result<(), VMHooksEarlyExit> {
1516 self.handler
1517 .bi_t_mod(destination_handle, op1_handle, op2_handle)
1518 }
1519
1520 fn big_int_ediv(
1521 &mut self,
1522 destination_handle: i32,
1523 op1_handle: i32,
1524 op2_handle: i32,
1525 ) -> Result<(), VMHooksEarlyExit> {
1526 panic!("Not supported: big_int_ediv");
1527 }
1528
1529 fn big_int_emod(
1530 &mut self,
1531 destination_handle: i32,
1532 op1_handle: i32,
1533 op2_handle: i32,
1534 ) -> Result<(), VMHooksEarlyExit> {
1535 panic!("Not supported: big_int_emod");
1536 }
1537
1538 fn big_int_sqrt(
1539 &mut self,
1540 destination_handle: i32,
1541 op_handle: i32,
1542 ) -> Result<(), VMHooksEarlyExit> {
1543 self.handler.bi_sqrt(destination_handle, op_handle)
1544 }
1545
1546 fn big_int_pow(
1547 &mut self,
1548 destination_handle: i32,
1549 op1_handle: i32,
1550 op2_handle: i32,
1551 ) -> Result<(), VMHooksEarlyExit> {
1552 self.handler
1553 .bi_pow(destination_handle, op1_handle, op2_handle)
1554 }
1555
1556 fn big_int_log2(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1557 self.handler.bi_log2(op_handle)
1558 }
1559
1560 fn big_int_abs(
1561 &mut self,
1562 destination_handle: i32,
1563 op_handle: i32,
1564 ) -> Result<(), VMHooksEarlyExit> {
1565 self.handler.bi_abs(destination_handle, op_handle)
1566 }
1567
1568 fn big_int_neg(
1569 &mut self,
1570 destination_handle: i32,
1571 op_handle: i32,
1572 ) -> Result<(), VMHooksEarlyExit> {
1573 self.handler.bi_neg(destination_handle, op_handle)
1574 }
1575
1576 fn big_int_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1577 self.handler.bi_sign(op_handle)
1578 }
1579
1580 fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1581 self.handler.bi_cmp(op1_handle, op2_handle)
1582 }
1583
1584 fn big_int_not(
1585 &mut self,
1586 destination_handle: i32,
1587 op_handle: i32,
1588 ) -> Result<(), VMHooksEarlyExit> {
1589 panic!("Unavailable: big_int_not");
1590 }
1591
1592 fn big_int_and(
1593 &mut self,
1594 destination_handle: i32,
1595 op1_handle: i32,
1596 op2_handle: i32,
1597 ) -> Result<(), VMHooksEarlyExit> {
1598 self.handler
1599 .bi_and(destination_handle, op1_handle, op2_handle)
1600 }
1601
1602 fn big_int_or(
1603 &mut self,
1604 destination_handle: i32,
1605 op1_handle: i32,
1606 op2_handle: i32,
1607 ) -> Result<(), VMHooksEarlyExit> {
1608 self.handler
1609 .bi_or(destination_handle, op1_handle, op2_handle)
1610 }
1611
1612 fn big_int_xor(
1613 &mut self,
1614 destination_handle: i32,
1615 op1_handle: i32,
1616 op2_handle: i32,
1617 ) -> Result<(), VMHooksEarlyExit> {
1618 self.handler
1619 .bi_xor(destination_handle, op1_handle, op2_handle)
1620 }
1621
1622 fn big_int_shr(
1623 &mut self,
1624 destination_handle: i32,
1625 op_handle: i32,
1626 bits: i32,
1627 ) -> Result<(), VMHooksEarlyExit> {
1628 self.handler
1629 .bi_shr(destination_handle, op_handle, bits as usize)
1630 }
1631
1632 fn big_int_shl(
1633 &mut self,
1634 destination_handle: i32,
1635 op_handle: i32,
1636 bits: i32,
1637 ) -> Result<(), VMHooksEarlyExit> {
1638 self.handler
1639 .bi_shl(destination_handle, op_handle, bits as usize)
1640 }
1641
1642 fn big_int_finish_unsigned(&mut self, reference_handle: i32) -> Result<(), VMHooksEarlyExit> {
1643 self.handler.finish_big_uint_raw(reference_handle)
1644 }
1645
1646 fn big_int_finish_signed(&mut self, reference_handle: i32) -> Result<(), VMHooksEarlyExit> {
1647 self.handler.finish_big_int_raw(reference_handle)
1648 }
1649
1650 fn big_int_to_string(
1651 &mut self,
1652 big_int_handle: i32,
1653 destination_handle: i32,
1654 ) -> Result<(), VMHooksEarlyExit> {
1655 self.handler
1656 .bi_to_string(big_int_handle, destination_handle)
1657 }
1658
1659 fn mbuffer_new(&mut self) -> Result<i32, VMHooksEarlyExit> {
1660 self.handler.mb_new_empty()
1661 }
1662
1663 fn mbuffer_new_from_bytes(
1664 &mut self,
1665 data_offset: MemPtr,
1666 data_length: MemLength,
1667 ) -> Result<i32, VMHooksEarlyExit> {
1668 unsafe {
1669 let bytes = self.handler.context.memory_load(data_offset, data_length);
1670 self.handler.mb_new_from_bytes(&bytes)
1671 }
1672 }
1673
1674 fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1675 Ok(self.handler.mb_len(m_buffer_handle)? as i32)
1676 }
1677
1678 fn mbuffer_get_bytes(
1679 &mut self,
1680 m_buffer_handle: i32,
1681 result_offset: MemPtr,
1682 ) -> Result<i32, VMHooksEarlyExit> {
1683 let bytes = self.handler.mb_get_bytes(m_buffer_handle)?;
1684 unsafe {
1685 self.handler.context.memory_store(result_offset, &bytes);
1686 }
1687 Ok(bytes.len() as i32)
1688 }
1689
1690 fn mbuffer_get_byte_slice(
1691 &mut self,
1692 source_handle: i32,
1693 starting_position: i32,
1694 slice_length: i32,
1695 result_offset: MemPtr,
1696 ) -> Result<i32, VMHooksEarlyExit> {
1697 self.handler.mb_get_slice(
1698 source_handle,
1699 starting_position as usize,
1700 slice_length as usize,
1701 result_offset,
1702 )
1703 }
1704
1705 fn mbuffer_copy_byte_slice(
1706 &mut self,
1707 source_handle: i32,
1708 starting_position: i32,
1709 slice_length: i32,
1710 destination_handle: i32,
1711 ) -> Result<i32, VMHooksEarlyExit> {
1712 self.handler.mb_copy_slice(
1713 source_handle,
1714 starting_position as usize,
1715 slice_length as usize,
1716 destination_handle,
1717 )
1718 }
1719
1720 fn mbuffer_eq(
1721 &mut self,
1722 m_buffer_handle1: i32,
1723 m_buffer_handle2: i32,
1724 ) -> Result<i32, VMHooksEarlyExit> {
1725 self.handler.mb_eq(m_buffer_handle1, m_buffer_handle2)
1726 }
1727
1728 fn mbuffer_set_bytes(
1729 &mut self,
1730 m_buffer_handle: i32,
1731 data_offset: MemPtr,
1732 data_length: MemLength,
1733 ) -> Result<i32, VMHooksEarlyExit> {
1734 unsafe {
1735 let bytes = self.handler.context.memory_load(data_offset, data_length);
1736 match self.handler.mb_set(m_buffer_handle, &bytes) {
1737 Ok(_) => Ok(RESULT_OK),
1738 Err(e) => Err(e),
1739 }
1740 }
1741 }
1742
1743 fn mbuffer_set_byte_slice(
1744 &mut self,
1745 m_buffer_handle: i32,
1746 starting_position: i32,
1747 data_length: MemLength,
1748 data_offset: MemPtr,
1749 ) -> Result<i32, VMHooksEarlyExit> {
1750 unsafe {
1751 let bytes = self.handler.context.memory_load(data_offset, data_length);
1752 self.handler
1753 .mb_set_slice(m_buffer_handle, starting_position as usize, &bytes)
1754 }
1755 }
1756
1757 fn mbuffer_append(
1758 &mut self,
1759 accumulator_handle: i32,
1760 data_handle: i32,
1761 ) -> Result<i32, VMHooksEarlyExit> {
1762 match self.handler.mb_append(accumulator_handle, data_handle) {
1763 Ok(_) => Ok(RESULT_OK),
1764 Err(e) => Err(e),
1765 }
1766 }
1767
1768 fn mbuffer_append_bytes(
1769 &mut self,
1770 accumulator_handle: i32,
1771 data_offset: MemPtr,
1772 data_length: MemLength,
1773 ) -> Result<i32, VMHooksEarlyExit> {
1774 unsafe {
1775 let bytes = self.handler.context.memory_load(data_offset, data_length);
1776 match self.handler.mb_append_bytes(accumulator_handle, &bytes) {
1777 Ok(_) => Ok(RESULT_OK),
1778 Err(e) => Err(e),
1779 }
1780 }
1781 }
1782
1783 fn mbuffer_to_big_int_unsigned(
1784 &mut self,
1785 m_buffer_handle: i32,
1786 big_int_handle: i32,
1787 ) -> Result<i32, VMHooksEarlyExit> {
1788 match self
1789 .handler
1790 .mb_to_big_int_unsigned(m_buffer_handle, big_int_handle)
1791 {
1792 Ok(_) => Ok(RESULT_OK),
1793 Err(e) => Err(e),
1794 }
1795 }
1796
1797 fn mbuffer_to_big_int_signed(
1798 &mut self,
1799 m_buffer_handle: i32,
1800 big_int_handle: i32,
1801 ) -> Result<i32, VMHooksEarlyExit> {
1802 match self
1803 .handler
1804 .mb_to_big_int_signed(m_buffer_handle, big_int_handle)
1805 {
1806 Ok(_) => Ok(RESULT_OK),
1807 Err(e) => Err(e),
1808 }
1809 }
1810
1811 fn mbuffer_from_big_int_unsigned(
1812 &mut self,
1813 m_buffer_handle: i32,
1814 big_int_handle: i32,
1815 ) -> Result<i32, VMHooksEarlyExit> {
1816 match self
1817 .handler
1818 .mb_from_big_int_unsigned(m_buffer_handle, big_int_handle)
1819 {
1820 Ok(_) => Ok(RESULT_OK),
1821 Err(e) => Err(e),
1822 }
1823 }
1824
1825 fn mbuffer_from_big_int_signed(
1826 &mut self,
1827 m_buffer_handle: i32,
1828 big_int_handle: i32,
1829 ) -> Result<i32, VMHooksEarlyExit> {
1830 match self
1831 .handler
1832 .mb_from_big_int_signed(m_buffer_handle, big_int_handle)
1833 {
1834 Ok(_) => Ok(RESULT_OK),
1835 Err(e) => Err(e),
1836 }
1837 }
1838
1839 fn mbuffer_to_small_int_unsigned(
1840 &mut self,
1841 m_buffer_handle: i32,
1842 ) -> Result<i64, VMHooksEarlyExit> {
1843 self.handler.mb_to_small_int_unsigned(m_buffer_handle)
1844 }
1845
1846 fn mbuffer_to_small_int_signed(
1847 &mut self,
1848 m_buffer_handle: i32,
1849 ) -> Result<i64, VMHooksEarlyExit> {
1850 self.handler.mb_to_small_int_signed(m_buffer_handle)
1851 }
1852
1853 fn mbuffer_from_small_int_unsigned(
1854 &mut self,
1855 m_buffer_handle: i32,
1856 value: i64,
1857 ) -> Result<(), VMHooksEarlyExit> {
1858 self.handler
1859 .mb_from_small_int_unsigned(m_buffer_handle, value as u64)
1860 }
1861
1862 fn mbuffer_from_small_int_signed(
1863 &mut self,
1864 m_buffer_handle: i32,
1865 value: i64,
1866 ) -> Result<(), VMHooksEarlyExit> {
1867 self.handler
1868 .mb_from_small_int_signed(m_buffer_handle, value)
1869 }
1870
1871 fn mbuffer_to_big_float(
1872 &mut self,
1873 m_buffer_handle: i32,
1874 big_float_handle: i32,
1875 ) -> Result<i32, VMHooksEarlyExit> {
1876 panic!("Unavailable: mbuffer_to_big_float")
1877 }
1878
1879 fn mbuffer_from_big_float(
1880 &mut self,
1881 m_buffer_handle: i32,
1882 big_float_handle: i32,
1883 ) -> Result<i32, VMHooksEarlyExit> {
1884 panic!("Unavailable: mbuffer_from_big_float")
1885 }
1886
1887 fn mbuffer_storage_store(
1888 &mut self,
1889 key_handle: i32,
1890 source_handle: i32,
1891 ) -> Result<i32, VMHooksEarlyExit> {
1892 match self
1893 .handler
1894 .storage_store_managed_buffer_raw(key_handle, source_handle)
1895 {
1896 Ok(_) => Ok(RESULT_OK),
1897 Err(e) => Err(e),
1898 }
1899 }
1900
1901 fn mbuffer_storage_load(
1902 &mut self,
1903 key_handle: i32,
1904 destination_handle: i32,
1905 ) -> Result<i32, VMHooksEarlyExit> {
1906 match self
1907 .handler
1908 .storage_load_managed_buffer_raw(key_handle, destination_handle)
1909 {
1910 Ok(_) => Ok(RESULT_OK),
1911 Err(e) => Err(e),
1912 }
1913 }
1914
1915 fn mbuffer_storage_load_from_address(
1916 &mut self,
1917 address_handle: i32,
1918 key_handle: i32,
1919 destination_handle: i32,
1920 ) -> Result<(), VMHooksEarlyExit> {
1921 self.handler
1922 .storage_load_from_address(address_handle, key_handle, destination_handle)
1923 }
1924
1925 fn mbuffer_get_argument(
1926 &mut self,
1927 id: i32,
1928 destination_handle: i32,
1929 ) -> Result<i32, VMHooksEarlyExit> {
1930 match self
1931 .handler
1932 .load_argument_managed_buffer(id, destination_handle)
1933 {
1934 Ok(_) => Ok(RESULT_OK),
1935 Err(e) => Err(e),
1936 }
1937 }
1938
1939 fn mbuffer_finish(&mut self, source_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1940 match self.handler.finish_managed_buffer_raw(source_handle) {
1941 Ok(_) => Ok(RESULT_OK),
1942 Err(e) => Err(e),
1943 }
1944 }
1945
1946 fn mbuffer_set_random(
1947 &mut self,
1948 destination_handle: i32,
1949 length: i32,
1950 ) -> Result<i32, VMHooksEarlyExit> {
1951 match self
1952 .handler
1953 .mb_set_random(destination_handle, length as usize)
1954 {
1955 Ok(_) => Ok(RESULT_OK),
1956 Err(e) => Err(e),
1957 }
1958 }
1959
1960 fn managed_map_new(&mut self) -> Result<i32, VMHooksEarlyExit> {
1961 Ok(self.handler.mm_new())
1962 }
1963
1964 fn managed_map_put(
1965 &mut self,
1966 map_handle: i32,
1967 key_handle: i32,
1968 value_handle: i32,
1969 ) -> Result<i32, VMHooksEarlyExit> {
1970 self.handler.mm_put(map_handle, key_handle, value_handle);
1971 Ok(RESULT_OK)
1972 }
1973
1974 fn managed_map_get(
1975 &mut self,
1976 map_handle: i32,
1977 key_handle: i32,
1978 out_value_handle: i32,
1979 ) -> Result<i32, VMHooksEarlyExit> {
1980 self.handler
1981 .mm_get(map_handle, key_handle, out_value_handle);
1982 Ok(RESULT_OK)
1983 }
1984
1985 fn managed_map_remove(
1986 &mut self,
1987 map_handle: i32,
1988 key_handle: i32,
1989 out_value_handle: i32,
1990 ) -> Result<i32, VMHooksEarlyExit> {
1991 self.handler
1992 .mm_remove(map_handle, key_handle, out_value_handle);
1993 Ok(RESULT_OK)
1994 }
1995
1996 fn managed_map_contains(
1997 &mut self,
1998 map_handle: i32,
1999 key_handle: i32,
2000 ) -> Result<i32, VMHooksEarlyExit> {
2001 map_bool_to_i32(Ok(self.handler.mm_contains(map_handle, key_handle)))
2002 }
2003
2004 fn small_int_get_unsigned_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
2005 Ok(self.handler.get_argument_u64(id)? as i64)
2006 }
2007
2008 fn small_int_get_signed_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
2009 self.handler.get_argument_i64(id)
2010 }
2011
2012 fn small_int_finish_unsigned(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2013 self.handler.finish_u64(value as u64)
2014 }
2015
2016 fn small_int_finish_signed(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2017 self.handler.finish_i64(value)
2018 }
2019
2020 fn small_int_storage_store_unsigned(
2021 &mut self,
2022 key_offset: MemPtr,
2023 key_length: MemLength,
2024 value: i64,
2025 ) -> Result<i32, VMHooksEarlyExit> {
2026 panic!("Unavailable: small_int_storage_store_unsigned")
2027 }
2028
2029 fn small_int_storage_store_signed(
2030 &mut self,
2031 key_offset: MemPtr,
2032 key_length: MemLength,
2033 value: i64,
2034 ) -> Result<i32, VMHooksEarlyExit> {
2035 panic!("Unavailable: small_int_storage_store_signed")
2036 }
2037
2038 fn small_int_storage_load_unsigned(
2039 &mut self,
2040 key_offset: MemPtr,
2041 key_length: MemLength,
2042 ) -> Result<i64, VMHooksEarlyExit> {
2043 panic!("Unavailable: small_int_storage_load_unsigned")
2044 }
2045
2046 fn small_int_storage_load_signed(
2047 &mut self,
2048 key_offset: MemPtr,
2049 key_length: MemLength,
2050 ) -> Result<i64, VMHooksEarlyExit> {
2051 panic!("Unavailable: small_int_storage_load_signed")
2052 }
2053
2054 fn int64get_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
2055 panic!("Unavailable: int64get_argument")
2056 }
2057
2058 fn int64finish(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2059 panic!("Unavailable: int64finish");
2060 }
2061
2062 fn int64storage_store(
2063 &mut self,
2064 key_offset: MemPtr,
2065 key_length: MemLength,
2066 value: i64,
2067 ) -> Result<i32, VMHooksEarlyExit> {
2068 panic!("Unavailable: int64storage_store")
2069 }
2070
2071 fn int64storage_load(
2072 &mut self,
2073 key_offset: MemPtr,
2074 key_length: MemLength,
2075 ) -> Result<i64, VMHooksEarlyExit> {
2076 panic!("Unavailable: int64storage_load")
2077 }
2078
2079 fn sha256(
2080 &mut self,
2081 data_offset: MemPtr,
2082 length: MemLength,
2083 result_offset: MemPtr,
2084 ) -> Result<i32, VMHooksEarlyExit> {
2085 panic!("Unavailable: sha256")
2086 }
2087
2088 fn managed_sha256(
2089 &mut self,
2090 input_handle: i32,
2091 output_handle: i32,
2092 ) -> Result<i32, VMHooksEarlyExit> {
2093 match self.handler.sha256_managed(output_handle, input_handle) {
2094 Ok(_) => Ok(RESULT_OK),
2095 Err(e) => Err(e),
2096 }
2097 }
2098
2099 fn keccak256(
2100 &mut self,
2101 data_offset: MemPtr,
2102 length: MemLength,
2103 result_offset: MemPtr,
2104 ) -> Result<i32, VMHooksEarlyExit> {
2105 panic!("Unavailable: keccak256")
2106 }
2107
2108 fn managed_keccak256(
2109 &mut self,
2110 input_handle: i32,
2111 output_handle: i32,
2112 ) -> Result<i32, VMHooksEarlyExit> {
2113 match self.handler.keccak256_managed(output_handle, input_handle) {
2114 Ok(_) => Ok(RESULT_OK),
2115 Err(e) => Err(e),
2116 }
2117 }
2118
2119 fn ripemd160(
2120 &mut self,
2121 data_offset: MemPtr,
2122 length: MemLength,
2123 result_offset: MemPtr,
2124 ) -> Result<i32, VMHooksEarlyExit> {
2125 panic!("Unavailable: ripemd160")
2126 }
2127
2128 fn managed_ripemd160(
2129 &mut self,
2130 input_handle: i32,
2131 output_handle: i32,
2132 ) -> Result<i32, VMHooksEarlyExit> {
2133 panic!("Unavailable: managed_ripemd160")
2134 }
2135
2136 fn verify_bls(
2137 &mut self,
2138 key_offset: MemPtr,
2139 message_offset: MemPtr,
2140 message_length: MemLength,
2141 sig_offset: MemPtr,
2142 ) -> Result<i32, VMHooksEarlyExit> {
2143 panic!("Unavailable: verify_bls")
2144 }
2145
2146 fn managed_verify_bls(
2147 &mut self,
2148 key_handle: i32,
2149 message_handle: i32,
2150 sig_handle: i32,
2151 ) -> Result<i32, VMHooksEarlyExit> {
2152 self.handler
2153 .verify_bls_managed(key_handle, message_handle, sig_handle)?;
2154 Ok(0)
2155 }
2156
2157 fn verify_ed25519(
2158 &mut self,
2159 key_offset: MemPtr,
2160 message_offset: MemPtr,
2161 message_length: MemLength,
2162 sig_offset: MemPtr,
2163 ) -> Result<i32, VMHooksEarlyExit> {
2164 panic!("Unavailable: verify_ed25519")
2165 }
2166
2167 fn managed_verify_ed25519(
2168 &mut self,
2169 key_handle: i32,
2170 message_handle: i32,
2171 sig_handle: i32,
2172 ) -> Result<i32, VMHooksEarlyExit> {
2173 match self
2174 .handler
2175 .verify_ed25519_managed(key_handle, message_handle, sig_handle)
2176 {
2177 Ok(_) => Ok(RESULT_OK),
2178 Err(e) => Err(e),
2179 }
2180 }
2181
2182 fn verify_custom_secp256k1(
2183 &mut self,
2184 key_offset: MemPtr,
2185 key_length: MemLength,
2186 message_offset: MemPtr,
2187 message_length: MemLength,
2188 sig_offset: MemPtr,
2189 hash_type: i32,
2190 ) -> Result<i32, VMHooksEarlyExit> {
2191 panic!("Unavailable: verify_custom_secp256k1")
2192 }
2193
2194 fn managed_verify_custom_secp256k1(
2195 &mut self,
2196 key_handle: i32,
2197 message_handle: i32,
2198 sig_handle: i32,
2199 hash_type: i32,
2200 ) -> Result<i32, VMHooksEarlyExit> {
2201 panic!("Unavailable: managed_verify_custom_secp256k1")
2202 }
2203
2204 fn verify_secp256k1(
2205 &mut self,
2206 key_offset: MemPtr,
2207 key_length: MemLength,
2208 message_offset: MemPtr,
2209 message_length: MemLength,
2210 sig_offset: MemPtr,
2211 ) -> Result<i32, VMHooksEarlyExit> {
2212 panic!("Unavailable: verify_secp256k1")
2213 }
2214
2215 fn managed_verify_secp256k1(
2216 &mut self,
2217 key_handle: i32,
2218 message_handle: i32,
2219 sig_handle: i32,
2220 ) -> Result<i32, VMHooksEarlyExit> {
2221 panic!("Unavailable: managed_verify_secp256k1")
2222 }
2223
2224 fn encode_secp256k1_der_signature(
2225 &mut self,
2226 r_offset: MemPtr,
2227 r_length: MemLength,
2228 s_offset: MemPtr,
2229 s_length: MemLength,
2230 sig_offset: MemPtr,
2231 ) -> Result<i32, VMHooksEarlyExit> {
2232 panic!("Unavailable: encode_secp256k1_der_signature")
2233 }
2234
2235 fn managed_encode_secp256k1_der_signature(
2236 &mut self,
2237 r_handle: i32,
2238 s_handle: i32,
2239 sig_handle: i32,
2240 ) -> Result<i32, VMHooksEarlyExit> {
2241 panic!("Unavailable: managed_encode_secp256k1_der_signature")
2242 }
2243
2244 fn add_ec(
2245 &mut self,
2246 x_result_handle: i32,
2247 y_result_handle: i32,
2248 ec_handle: i32,
2249 fst_point_xhandle: i32,
2250 fst_point_yhandle: i32,
2251 snd_point_xhandle: i32,
2252 snd_point_yhandle: i32,
2253 ) -> Result<(), VMHooksEarlyExit> {
2254 panic!("Unavailable: add_ec");
2255 }
2256
2257 fn double_ec(
2258 &mut self,
2259 x_result_handle: i32,
2260 y_result_handle: i32,
2261 ec_handle: i32,
2262 point_xhandle: i32,
2263 point_yhandle: i32,
2264 ) -> Result<(), VMHooksEarlyExit> {
2265 panic!("Unavailable: double_ec");
2266 }
2267
2268 fn is_on_curve_ec(
2269 &mut self,
2270 ec_handle: i32,
2271 point_xhandle: i32,
2272 point_yhandle: i32,
2273 ) -> Result<i32, VMHooksEarlyExit> {
2274 panic!("Unavailable: is_on_curve_ec")
2275 }
2276
2277 fn scalar_base_mult_ec(
2278 &mut self,
2279 x_result_handle: i32,
2280 y_result_handle: i32,
2281 ec_handle: i32,
2282 data_offset: MemPtr,
2283 length: MemLength,
2284 ) -> Result<i32, VMHooksEarlyExit> {
2285 panic!("Unavailable: scalar_base_mult_ec")
2286 }
2287
2288 fn managed_scalar_base_mult_ec(
2289 &mut self,
2290 x_result_handle: i32,
2291 y_result_handle: i32,
2292 ec_handle: i32,
2293 data_handle: i32,
2294 ) -> Result<i32, VMHooksEarlyExit> {
2295 panic!("Unavailable: managed_scalar_base_mult_ec")
2296 }
2297
2298 fn scalar_mult_ec(
2299 &mut self,
2300 x_result_handle: i32,
2301 y_result_handle: i32,
2302 ec_handle: i32,
2303 point_xhandle: i32,
2304 point_yhandle: i32,
2305 data_offset: MemPtr,
2306 length: MemLength,
2307 ) -> Result<i32, VMHooksEarlyExit> {
2308 panic!("Unavailable: scalar_mult_ec")
2309 }
2310
2311 fn managed_scalar_mult_ec(
2312 &mut self,
2313 x_result_handle: i32,
2314 y_result_handle: i32,
2315 ec_handle: i32,
2316 point_xhandle: i32,
2317 point_yhandle: i32,
2318 data_handle: i32,
2319 ) -> Result<i32, VMHooksEarlyExit> {
2320 panic!("Unavailable: managed_scalar_mult_ec")
2321 }
2322
2323 fn marshal_ec(
2324 &mut self,
2325 x_pair_handle: i32,
2326 y_pair_handle: i32,
2327 ec_handle: i32,
2328 result_offset: MemPtr,
2329 ) -> Result<i32, VMHooksEarlyExit> {
2330 panic!("Unavailable: marshal_ec")
2331 }
2332
2333 fn managed_marshal_ec(
2334 &mut self,
2335 x_pair_handle: i32,
2336 y_pair_handle: i32,
2337 ec_handle: i32,
2338 result_handle: i32,
2339 ) -> Result<i32, VMHooksEarlyExit> {
2340 panic!("Unavailable: managed_marshal_ec")
2341 }
2342
2343 fn marshal_compressed_ec(
2344 &mut self,
2345 x_pair_handle: i32,
2346 y_pair_handle: i32,
2347 ec_handle: i32,
2348 result_offset: MemPtr,
2349 ) -> Result<i32, VMHooksEarlyExit> {
2350 panic!("Unavailable: marshal_compressed_ec")
2351 }
2352
2353 fn managed_marshal_compressed_ec(
2354 &mut self,
2355 x_pair_handle: i32,
2356 y_pair_handle: i32,
2357 ec_handle: i32,
2358 result_handle: i32,
2359 ) -> Result<i32, VMHooksEarlyExit> {
2360 panic!("Unavailable: managed_marshal_compressed_ec")
2361 }
2362
2363 fn unmarshal_ec(
2364 &mut self,
2365 x_result_handle: i32,
2366 y_result_handle: i32,
2367 ec_handle: i32,
2368 data_offset: MemPtr,
2369 length: MemLength,
2370 ) -> Result<i32, VMHooksEarlyExit> {
2371 panic!("Unavailable: unmarshal_ec")
2372 }
2373
2374 fn managed_unmarshal_ec(
2375 &mut self,
2376 x_result_handle: i32,
2377 y_result_handle: i32,
2378 ec_handle: i32,
2379 data_handle: i32,
2380 ) -> Result<i32, VMHooksEarlyExit> {
2381 panic!("Unavailable: managed_unmarshal_ec")
2382 }
2383
2384 fn unmarshal_compressed_ec(
2385 &mut self,
2386 x_result_handle: i32,
2387 y_result_handle: i32,
2388 ec_handle: i32,
2389 data_offset: MemPtr,
2390 length: MemLength,
2391 ) -> Result<i32, VMHooksEarlyExit> {
2392 panic!("Unavailable: unmarshal_compressed_ec")
2393 }
2394
2395 fn managed_unmarshal_compressed_ec(
2396 &mut self,
2397 x_result_handle: i32,
2398 y_result_handle: i32,
2399 ec_handle: i32,
2400 data_handle: i32,
2401 ) -> Result<i32, VMHooksEarlyExit> {
2402 panic!("Unavailable: managed_unmarshal_compressed_ec")
2403 }
2404
2405 fn generate_key_ec(
2406 &mut self,
2407 x_pub_key_handle: i32,
2408 y_pub_key_handle: i32,
2409 ec_handle: i32,
2410 result_offset: MemPtr,
2411 ) -> Result<i32, VMHooksEarlyExit> {
2412 panic!("Unavailable: generate_key_ec")
2413 }
2414
2415 fn managed_generate_key_ec(
2416 &mut self,
2417 x_pub_key_handle: i32,
2418 y_pub_key_handle: i32,
2419 ec_handle: i32,
2420 result_handle: i32,
2421 ) -> Result<i32, VMHooksEarlyExit> {
2422 panic!("Unavailable: managed_generate_key_ec")
2423 }
2424
2425 fn create_ec(
2426 &mut self,
2427 data_offset: MemPtr,
2428 data_length: MemLength,
2429 ) -> Result<i32, VMHooksEarlyExit> {
2430 panic!("Unavailable: create_ec")
2431 }
2432
2433 fn managed_create_ec(&mut self, data_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2434 panic!("Unavailable: managed_create_ec")
2435 }
2436
2437 fn get_curve_length_ec(&mut self, ec_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2438 panic!("Unavailable: get_curve_length_ec")
2439 }
2440
2441 fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2442 panic!("Unavailable: get_priv_key_byte_length_ec")
2443 }
2444
2445 fn elliptic_curve_get_values(
2446 &mut self,
2447 ec_handle: i32,
2448 field_order_handle: i32,
2449 base_point_order_handle: i32,
2450 eq_constant_handle: i32,
2451 x_base_point_handle: i32,
2452 y_base_point_handle: i32,
2453 ) -> Result<i32, VMHooksEarlyExit> {
2454 panic!("Unavailable: elliptic_curve_get_values")
2455 }
2456
2457 fn is_reserved_function_name(&mut self, name_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2458 panic!("Unavailable: is_reserved_function_name")
2459 }
2460
2461 fn managed_get_original_caller_addr(
2462 &mut self,
2463 destination_handle: i32,
2464 ) -> Result<(), VMHooksEarlyExit> {
2465 panic!("Unavailable: managed_get_original_caller_addr")
2466 }
2467
2468 fn managed_get_relayer_addr(
2469 &mut self,
2470 destination_handle: i32,
2471 ) -> Result<(), VMHooksEarlyExit> {
2472 panic!("Unavailable: managed_get_relayer_addr")
2473 }
2474
2475 fn managed_multi_transfer_esdt_nft_execute_by_user(
2476 &mut self,
2477 user_handle: i32,
2478 dst_handle: i32,
2479 token_transfers_handle: i32,
2480 gas_limit: i64,
2481 function_handle: i32,
2482 arguments_handle: i32,
2483 ) -> Result<i32, VMHooksEarlyExit> {
2484 panic!("Unavailable: managed_multi_transfer_esdt_nft_execute_by_user")
2485 }
2486
2487 fn managed_verify_secp256r1(
2488 &mut self,
2489 key_handle: i32,
2490 message_handle: i32,
2491 sig_handle: i32,
2492 ) -> Result<i32, VMHooksEarlyExit> {
2493 panic!("Unavailable: managed_verify_secp256r1")
2494 }
2495
2496 fn managed_verify_blssignature_share(
2497 &mut self,
2498 key_handle: i32,
2499 message_handle: i32,
2500 sig_handle: i32,
2501 ) -> Result<i32, VMHooksEarlyExit> {
2502 self.handler
2503 .verify_bls_signature_share(key_handle, message_handle, sig_handle)?;
2504 Ok(0)
2505 }
2506
2507 fn managed_verify_blsaggregated_signature(
2508 &mut self,
2509 key_handle: i32,
2510 message_handle: i32,
2511 sig_handle: i32,
2512 ) -> Result<i32, VMHooksEarlyExit> {
2513 self.handler
2514 .verify_bls_aggregated_signature(key_handle, message_handle, sig_handle)?;
2515 Ok(0)
2516 }
2517}