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 panic!("Unavailable: managed_execute_on_dest_context_with_error_return")
1020 }
1021
1022 fn managed_multi_transfer_esdt_nft_execute(
1023 &mut self,
1024 dst_handle: i32,
1025 token_transfers_handle: i32,
1026 gas_limit: i64,
1027 function_handle: i32,
1028 arguments_handle: i32,
1029 ) -> Result<i32, VMHooksEarlyExit> {
1030 self.handler.multi_transfer_esdt_nft_execute(
1031 dst_handle,
1032 token_transfers_handle,
1033 gas_limit as u64,
1034 function_handle,
1035 arguments_handle,
1036 )?;
1037 Ok(RESULT_OK)
1038 }
1039
1040 fn managed_multi_transfer_esdt_nft_execute_with_return(
1041 &mut self,
1042 dst_handle: i32,
1043 token_transfers_handle: i32,
1044 gas_limit: i64,
1045 function_handle: i32,
1046 arguments_handle: i32,
1047 ) -> Result<i32, VMHooksEarlyExit> {
1048 self.handler
1049 .managed_multi_transfer_esdt_nft_execute_with_return(
1050 dst_handle,
1051 token_transfers_handle,
1052 gas_limit as u64,
1053 function_handle,
1054 arguments_handle,
1055 )
1056 }
1057
1058 fn managed_transfer_value_execute(
1059 &mut self,
1060 dst_handle: i32,
1061 value_handle: i32,
1062 gas_limit: i64,
1063 function_handle: i32,
1064 arguments_handle: i32,
1065 ) -> Result<i32, VMHooksEarlyExit> {
1066 self.handler.transfer_value_execute(
1067 dst_handle,
1068 value_handle,
1069 gas_limit as u64,
1070 function_handle,
1071 arguments_handle,
1072 )?;
1073 Ok(RESULT_OK)
1074 }
1075
1076 fn managed_is_esdt_frozen(
1077 &mut self,
1078 address_handle: i32,
1079 token_id_handle: i32,
1080 nonce: i64,
1081 ) -> Result<i32, VMHooksEarlyExit> {
1082 map_bool_to_i32(self.handler.check_esdt_frozen(
1083 address_handle,
1084 token_id_handle,
1085 nonce as u64,
1086 ))
1087 }
1088
1089 fn managed_is_esdt_limited_transfer(
1090 &mut self,
1091 _token_id_handle: i32,
1092 ) -> Result<i32, VMHooksEarlyExit> {
1093 map_bool_to_i32(Ok(false))
1094 }
1095
1096 fn managed_is_esdt_paused(&mut self, _token_id_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1097 map_bool_to_i32(Ok(false))
1098 }
1099
1100 fn managed_buffer_to_hex(
1101 &mut self,
1102 source_handle: i32,
1103 dest_handle: i32,
1104 ) -> Result<(), VMHooksEarlyExit> {
1105 self.handler.mb_to_hex(source_handle, dest_handle)
1106 }
1107
1108 fn managed_get_code_metadata(
1109 &mut self,
1110 address_handle: i32,
1111 response_handle: i32,
1112 ) -> Result<(), VMHooksEarlyExit> {
1113 self.handler
1114 .managed_get_code_metadata(address_handle, response_handle)
1115 }
1116
1117 fn managed_get_code_hash(
1118 &mut self,
1119 address_handle: i32,
1120 code_hash_handle: i32,
1121 ) -> Result<(), VMHooksEarlyExit> {
1122 panic!("Unavailable: managed_get_code_hash")
1123 }
1124
1125 fn managed_is_builtin_function(
1126 &mut self,
1127 function_name_handle: i32,
1128 ) -> Result<i32, VMHooksEarlyExit> {
1129 map_bool_to_i32(
1130 self.handler
1131 .managed_is_builtin_function(function_name_handle),
1132 )
1133 }
1134
1135 fn big_float_new_from_parts(
1136 &mut self,
1137 integral_part: i32,
1138 fractional_part: i32,
1139 exponent: i32,
1140 ) -> Result<i32, VMHooksEarlyExit> {
1141 self.handler
1142 .bf_from_parts(integral_part, fractional_part, exponent)
1143 }
1144
1145 fn big_float_new_from_frac(
1146 &mut self,
1147 numerator: i64,
1148 denominator: i64,
1149 ) -> Result<i32, VMHooksEarlyExit> {
1150 self.handler.bf_from_frac(numerator, denominator)
1151 }
1152
1153 fn big_float_new_from_sci(
1154 &mut self,
1155 significand: i64,
1156 exponent: i64,
1157 ) -> Result<i32, VMHooksEarlyExit> {
1158 self.handler.bf_from_sci(significand, exponent)
1159 }
1160
1161 fn big_float_add(
1162 &mut self,
1163 destination_handle: i32,
1164 op1_handle: i32,
1165 op2_handle: i32,
1166 ) -> Result<(), VMHooksEarlyExit> {
1167 self.handler
1168 .bf_add(destination_handle, op1_handle, op2_handle)
1169 }
1170
1171 fn big_float_sub(
1172 &mut self,
1173 destination_handle: i32,
1174 op1_handle: i32,
1175 op2_handle: i32,
1176 ) -> Result<(), VMHooksEarlyExit> {
1177 self.handler
1178 .bf_sub(destination_handle, op1_handle, op2_handle)
1179 }
1180
1181 fn big_float_mul(
1182 &mut self,
1183 destination_handle: i32,
1184 op1_handle: i32,
1185 op2_handle: i32,
1186 ) -> Result<(), VMHooksEarlyExit> {
1187 self.handler
1188 .bf_mul(destination_handle, op1_handle, op2_handle)
1189 }
1190
1191 fn big_float_div(
1192 &mut self,
1193 destination_handle: i32,
1194 op1_handle: i32,
1195 op2_handle: i32,
1196 ) -> Result<(), VMHooksEarlyExit> {
1197 self.handler
1198 .bf_div(destination_handle, op1_handle, op2_handle)
1199 }
1200
1201 fn big_float_neg(
1202 &mut self,
1203 destination_handle: i32,
1204 op_handle: i32,
1205 ) -> Result<(), VMHooksEarlyExit> {
1206 self.handler.bf_neg(destination_handle, op_handle)
1207 }
1208
1209 fn big_float_clone(
1210 &mut self,
1211 destination_handle: i32,
1212 op_handle: i32,
1213 ) -> Result<(), VMHooksEarlyExit> {
1214 self.handler.bf_clone(destination_handle, op_handle)
1215 }
1216
1217 fn big_float_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1218 self.handler.bf_cmp(op1_handle, op2_handle)
1219 }
1220
1221 fn big_float_abs(
1222 &mut self,
1223 destination_handle: i32,
1224 op_handle: i32,
1225 ) -> Result<(), VMHooksEarlyExit> {
1226 self.handler.bf_abs(destination_handle, op_handle)
1227 }
1228
1229 fn big_float_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1230 self.handler.bf_sign(op_handle)
1231 }
1232
1233 fn big_float_sqrt(
1234 &mut self,
1235 destination_handle: i32,
1236 op_handle: i32,
1237 ) -> Result<(), VMHooksEarlyExit> {
1238 self.handler.bf_sqrt(destination_handle, op_handle)
1239 }
1240
1241 fn big_float_pow(
1242 &mut self,
1243 destination_handle: i32,
1244 op_handle: i32,
1245 exponent: i32,
1246 ) -> Result<(), VMHooksEarlyExit> {
1247 self.handler.bf_pow(destination_handle, op_handle, exponent)
1248 }
1249
1250 fn big_float_floor(
1251 &mut self,
1252 dest_big_int_handle: i32,
1253 op_handle: i32,
1254 ) -> Result<(), VMHooksEarlyExit> {
1255 self.handler.bf_floor(dest_big_int_handle, op_handle)
1256 }
1257
1258 fn big_float_ceil(
1259 &mut self,
1260 dest_big_int_handle: i32,
1261 op_handle: i32,
1262 ) -> Result<(), VMHooksEarlyExit> {
1263 self.handler.bf_ceil(dest_big_int_handle, op_handle)
1264 }
1265
1266 fn big_float_truncate(
1267 &mut self,
1268 dest_big_int_handle: i32,
1269 op_handle: i32,
1270 ) -> Result<(), VMHooksEarlyExit> {
1271 self.handler.bf_trunc(dest_big_int_handle, op_handle)
1272 }
1273
1274 fn big_float_set_int64(
1275 &mut self,
1276 destination_handle: i32,
1277 value: i64,
1278 ) -> Result<(), VMHooksEarlyExit> {
1279 self.handler.bf_set_i64(destination_handle, value)
1280 }
1281
1282 fn big_float_is_int(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1283 map_bool_to_i32(self.handler.bf_is_bi(op_handle))
1284 }
1285
1286 fn big_float_set_big_int(
1287 &mut self,
1288 destination_handle: i32,
1289 big_int_handle: i32,
1290 ) -> Result<(), VMHooksEarlyExit> {
1291 self.handler.bf_set_bi(destination_handle, big_int_handle)
1292 }
1293
1294 fn big_float_get_const_pi(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1295 self.handler.bf_get_const_pi(destination_handle)
1296 }
1297
1298 fn big_float_get_const_e(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1299 self.handler.bf_get_const_e(destination_handle)
1300 }
1301
1302 fn big_int_get_unsigned_argument(
1303 &mut self,
1304 id: i32,
1305 destination_handle: i32,
1306 ) -> Result<(), VMHooksEarlyExit> {
1307 self.handler
1308 .load_argument_big_int_unsigned(id, destination_handle)
1309 }
1310
1311 fn big_int_get_signed_argument(
1312 &mut self,
1313 id: i32,
1314 destination_handle: i32,
1315 ) -> Result<(), VMHooksEarlyExit> {
1316 self.handler
1317 .load_argument_big_int_signed(id, destination_handle)
1318 }
1319
1320 fn big_int_storage_store_unsigned(
1321 &mut self,
1322 key_offset: MemPtr,
1323 key_length: MemLength,
1324 source_handle: i32,
1325 ) -> Result<i32, VMHooksEarlyExit> {
1326 panic!("Unavailable: big_int_storage_store_unsigned")
1327 }
1328
1329 fn big_int_storage_load_unsigned(
1330 &mut self,
1331 key_offset: MemPtr,
1332 key_length: MemLength,
1333 destination_handle: i32,
1334 ) -> Result<i32, VMHooksEarlyExit> {
1335 panic!("Unavailable: big_int_storage_load_unsigned")
1336 }
1337
1338 fn big_int_get_call_value(&mut self, destination_handle: i32) -> Result<(), VMHooksEarlyExit> {
1339 self.handler.load_egld_value(destination_handle)
1340 }
1341
1342 fn big_int_get_esdt_call_value(&mut self, destination: i32) -> Result<(), VMHooksEarlyExit> {
1343 panic!("Unavailable: big_int_get_esdt_call_value");
1344 }
1345
1346 fn big_int_get_esdt_call_value_by_index(
1347 &mut self,
1348 destination_handle: i32,
1349 index: i32,
1350 ) -> Result<(), VMHooksEarlyExit> {
1351 panic!("Unavailable: big_int_get_esdt_call_value_by_index");
1352 }
1353
1354 fn big_int_get_external_balance(
1355 &mut self,
1356 address_offset: MemPtr,
1357 result: i32,
1358 ) -> Result<(), VMHooksEarlyExit> {
1359 unsafe {
1360 let address_bytes = self.handler.context.memory_load(address_offset, 32);
1361 self.handler.load_balance(&address_bytes, result)
1362 }
1363 }
1364
1365 fn big_int_get_esdt_external_balance(
1366 &mut self,
1367 address_offset: MemPtr,
1368 token_id_offset: MemPtr,
1369 token_id_len: MemLength,
1370 nonce: i64,
1371 result_handle: i32,
1372 ) -> Result<(), VMHooksEarlyExit> {
1373 unsafe {
1374 let address_bytes = self.handler.context.memory_load(address_offset, 32);
1375 let token_id_bytes = self
1376 .handler
1377 .context
1378 .memory_load(token_id_offset, token_id_len);
1379 self.handler.big_int_get_esdt_external_balance(
1380 &address_bytes,
1381 &token_id_bytes,
1382 nonce as u64,
1383 result_handle,
1384 )
1385 }
1386 }
1387
1388 fn big_int_new(&mut self, small_value: i64) -> Result<i32, VMHooksEarlyExit> {
1389 self.handler.bi_new(small_value)
1390 }
1391
1392 fn big_int_unsigned_byte_length(
1393 &mut self,
1394 reference_handle: i32,
1395 ) -> Result<i32, VMHooksEarlyExit> {
1396 panic!("Unavailable: big_int_unsigned_byte_length")
1397 }
1398
1399 fn big_int_signed_byte_length(
1400 &mut self,
1401 reference_handle: i32,
1402 ) -> Result<i32, VMHooksEarlyExit> {
1403 panic!("Unavailable: big_int_signed_byte_length")
1404 }
1405
1406 fn big_int_get_unsigned_bytes(
1407 &mut self,
1408 reference_handle: i32,
1409 byte_offset: MemPtr,
1410 ) -> Result<i32, VMHooksEarlyExit> {
1411 panic!("Unavailable: big_int_get_unsigned_bytes")
1412 }
1413
1414 fn big_int_get_signed_bytes(
1415 &mut self,
1416 reference_handle: i32,
1417 byte_offset: MemPtr,
1418 ) -> Result<i32, VMHooksEarlyExit> {
1419 panic!("Unavailable: big_int_get_signed_bytes")
1420 }
1421
1422 fn big_int_set_unsigned_bytes(
1423 &mut self,
1424 destination_handle: i32,
1425 byte_offset: MemPtr,
1426 byte_length: MemLength,
1427 ) -> Result<(), VMHooksEarlyExit> {
1428 unsafe {
1429 let bytes = self.handler.context.memory_load(byte_offset, byte_length);
1430 self.handler
1431 .bi_set_unsigned_bytes(destination_handle, &bytes)
1432 }
1433 }
1434
1435 fn big_int_set_signed_bytes(
1436 &mut self,
1437 destination_handle: i32,
1438 byte_offset: MemPtr,
1439 byte_length: MemLength,
1440 ) -> Result<(), VMHooksEarlyExit> {
1441 unsafe {
1442 let bytes = self.handler.context.memory_load(byte_offset, byte_length);
1443 self.handler.bi_set_signed_bytes(destination_handle, &bytes)
1444 }
1445 }
1446
1447 fn big_int_is_int64(&mut self, destination_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1448 self.handler.bi_is_int64(destination_handle)
1449 }
1450
1451 fn big_int_get_int64(&mut self, destination_handle: i32) -> Result<i64, VMHooksEarlyExit> {
1452 self.handler.bi_get_int64(destination_handle)
1453 }
1454
1455 fn big_int_set_int64(
1456 &mut self,
1457 destination_handle: i32,
1458 value: i64,
1459 ) -> Result<(), VMHooksEarlyExit> {
1460 self.handler.bi_set_int64(destination_handle, value)
1461 }
1462
1463 fn big_int_add(
1464 &mut self,
1465 destination_handle: i32,
1466 op1_handle: i32,
1467 op2_handle: i32,
1468 ) -> Result<(), VMHooksEarlyExit> {
1469 self.handler
1470 .bi_add(destination_handle, op1_handle, op2_handle)
1471 }
1472
1473 fn big_int_sub(
1474 &mut self,
1475 destination_handle: i32,
1476 op1_handle: i32,
1477 op2_handle: i32,
1478 ) -> Result<(), VMHooksEarlyExit> {
1479 self.handler
1480 .bi_sub(destination_handle, op1_handle, op2_handle)
1481 }
1482
1483 fn big_int_mul(
1484 &mut self,
1485 destination_handle: i32,
1486 op1_handle: i32,
1487 op2_handle: i32,
1488 ) -> Result<(), VMHooksEarlyExit> {
1489 self.handler
1490 .bi_mul(destination_handle, op1_handle, op2_handle)
1491 }
1492
1493 fn big_int_tdiv(
1494 &mut self,
1495 destination_handle: i32,
1496 op1_handle: i32,
1497 op2_handle: i32,
1498 ) -> Result<(), VMHooksEarlyExit> {
1499 self.handler
1500 .bi_t_div(destination_handle, op1_handle, op2_handle)
1501 }
1502
1503 fn big_int_tmod(
1504 &mut self,
1505 destination_handle: i32,
1506 op1_handle: i32,
1507 op2_handle: i32,
1508 ) -> Result<(), VMHooksEarlyExit> {
1509 self.handler
1510 .bi_t_mod(destination_handle, op1_handle, op2_handle)
1511 }
1512
1513 fn big_int_ediv(
1514 &mut self,
1515 destination_handle: i32,
1516 op1_handle: i32,
1517 op2_handle: i32,
1518 ) -> Result<(), VMHooksEarlyExit> {
1519 panic!("Not supported: big_int_ediv");
1520 }
1521
1522 fn big_int_emod(
1523 &mut self,
1524 destination_handle: i32,
1525 op1_handle: i32,
1526 op2_handle: i32,
1527 ) -> Result<(), VMHooksEarlyExit> {
1528 panic!("Not supported: big_int_emod");
1529 }
1530
1531 fn big_int_sqrt(
1532 &mut self,
1533 destination_handle: i32,
1534 op_handle: i32,
1535 ) -> Result<(), VMHooksEarlyExit> {
1536 self.handler.bi_sqrt(destination_handle, op_handle)
1537 }
1538
1539 fn big_int_pow(
1540 &mut self,
1541 destination_handle: i32,
1542 op1_handle: i32,
1543 op2_handle: i32,
1544 ) -> Result<(), VMHooksEarlyExit> {
1545 self.handler
1546 .bi_pow(destination_handle, op1_handle, op2_handle)
1547 }
1548
1549 fn big_int_log2(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1550 self.handler.bi_log2(op_handle)
1551 }
1552
1553 fn big_int_abs(
1554 &mut self,
1555 destination_handle: i32,
1556 op_handle: i32,
1557 ) -> Result<(), VMHooksEarlyExit> {
1558 self.handler.bi_abs(destination_handle, op_handle)
1559 }
1560
1561 fn big_int_neg(
1562 &mut self,
1563 destination_handle: i32,
1564 op_handle: i32,
1565 ) -> Result<(), VMHooksEarlyExit> {
1566 self.handler.bi_neg(destination_handle, op_handle)
1567 }
1568
1569 fn big_int_sign(&mut self, op_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1570 self.handler.bi_sign(op_handle)
1571 }
1572
1573 fn big_int_cmp(&mut self, op1_handle: i32, op2_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1574 self.handler.bi_cmp(op1_handle, op2_handle)
1575 }
1576
1577 fn big_int_not(
1578 &mut self,
1579 destination_handle: i32,
1580 op_handle: i32,
1581 ) -> Result<(), VMHooksEarlyExit> {
1582 panic!("Unavailable: big_int_not");
1583 }
1584
1585 fn big_int_and(
1586 &mut self,
1587 destination_handle: i32,
1588 op1_handle: i32,
1589 op2_handle: i32,
1590 ) -> Result<(), VMHooksEarlyExit> {
1591 self.handler
1592 .bi_and(destination_handle, op1_handle, op2_handle)
1593 }
1594
1595 fn big_int_or(
1596 &mut self,
1597 destination_handle: i32,
1598 op1_handle: i32,
1599 op2_handle: i32,
1600 ) -> Result<(), VMHooksEarlyExit> {
1601 self.handler
1602 .bi_or(destination_handle, op1_handle, op2_handle)
1603 }
1604
1605 fn big_int_xor(
1606 &mut self,
1607 destination_handle: i32,
1608 op1_handle: i32,
1609 op2_handle: i32,
1610 ) -> Result<(), VMHooksEarlyExit> {
1611 self.handler
1612 .bi_xor(destination_handle, op1_handle, op2_handle)
1613 }
1614
1615 fn big_int_shr(
1616 &mut self,
1617 destination_handle: i32,
1618 op_handle: i32,
1619 bits: i32,
1620 ) -> Result<(), VMHooksEarlyExit> {
1621 self.handler
1622 .bi_shr(destination_handle, op_handle, bits as usize)
1623 }
1624
1625 fn big_int_shl(
1626 &mut self,
1627 destination_handle: i32,
1628 op_handle: i32,
1629 bits: i32,
1630 ) -> Result<(), VMHooksEarlyExit> {
1631 self.handler
1632 .bi_shl(destination_handle, op_handle, bits as usize)
1633 }
1634
1635 fn big_int_finish_unsigned(&mut self, reference_handle: i32) -> Result<(), VMHooksEarlyExit> {
1636 self.handler.finish_big_uint_raw(reference_handle)
1637 }
1638
1639 fn big_int_finish_signed(&mut self, reference_handle: i32) -> Result<(), VMHooksEarlyExit> {
1640 self.handler.finish_big_int_raw(reference_handle)
1641 }
1642
1643 fn big_int_to_string(
1644 &mut self,
1645 big_int_handle: i32,
1646 destination_handle: i32,
1647 ) -> Result<(), VMHooksEarlyExit> {
1648 self.handler
1649 .bi_to_string(big_int_handle, destination_handle)
1650 }
1651
1652 fn mbuffer_new(&mut self) -> Result<i32, VMHooksEarlyExit> {
1653 self.handler.mb_new_empty()
1654 }
1655
1656 fn mbuffer_new_from_bytes(
1657 &mut self,
1658 data_offset: MemPtr,
1659 data_length: MemLength,
1660 ) -> Result<i32, VMHooksEarlyExit> {
1661 unsafe {
1662 let bytes = self.handler.context.memory_load(data_offset, data_length);
1663 self.handler.mb_new_from_bytes(&bytes)
1664 }
1665 }
1666
1667 fn mbuffer_get_length(&mut self, m_buffer_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1668 Ok(self.handler.mb_len(m_buffer_handle)? as i32)
1669 }
1670
1671 fn mbuffer_get_bytes(
1672 &mut self,
1673 m_buffer_handle: i32,
1674 result_offset: MemPtr,
1675 ) -> Result<i32, VMHooksEarlyExit> {
1676 let bytes = self.handler.mb_get_bytes(m_buffer_handle)?;
1677 unsafe {
1678 self.handler.context.memory_store(result_offset, &bytes);
1679 }
1680 Ok(bytes.len() as i32)
1681 }
1682
1683 fn mbuffer_get_byte_slice(
1684 &mut self,
1685 source_handle: i32,
1686 starting_position: i32,
1687 slice_length: i32,
1688 result_offset: MemPtr,
1689 ) -> Result<i32, VMHooksEarlyExit> {
1690 self.handler.mb_get_slice(
1691 source_handle,
1692 starting_position as usize,
1693 slice_length as usize,
1694 result_offset,
1695 )
1696 }
1697
1698 fn mbuffer_copy_byte_slice(
1699 &mut self,
1700 source_handle: i32,
1701 starting_position: i32,
1702 slice_length: i32,
1703 destination_handle: i32,
1704 ) -> Result<i32, VMHooksEarlyExit> {
1705 self.handler.mb_copy_slice(
1706 source_handle,
1707 starting_position as usize,
1708 slice_length as usize,
1709 destination_handle,
1710 )
1711 }
1712
1713 fn mbuffer_eq(
1714 &mut self,
1715 m_buffer_handle1: i32,
1716 m_buffer_handle2: i32,
1717 ) -> Result<i32, VMHooksEarlyExit> {
1718 self.handler.mb_eq(m_buffer_handle1, m_buffer_handle2)
1719 }
1720
1721 fn mbuffer_set_bytes(
1722 &mut self,
1723 m_buffer_handle: i32,
1724 data_offset: MemPtr,
1725 data_length: MemLength,
1726 ) -> Result<i32, VMHooksEarlyExit> {
1727 unsafe {
1728 let bytes = self.handler.context.memory_load(data_offset, data_length);
1729 match self.handler.mb_set(m_buffer_handle, &bytes) {
1730 Ok(_) => Ok(RESULT_OK),
1731 Err(e) => Err(e),
1732 }
1733 }
1734 }
1735
1736 fn mbuffer_set_byte_slice(
1737 &mut self,
1738 m_buffer_handle: i32,
1739 starting_position: i32,
1740 data_length: MemLength,
1741 data_offset: MemPtr,
1742 ) -> Result<i32, VMHooksEarlyExit> {
1743 unsafe {
1744 let bytes = self.handler.context.memory_load(data_offset, data_length);
1745 self.handler
1746 .mb_set_slice(m_buffer_handle, starting_position as usize, &bytes)
1747 }
1748 }
1749
1750 fn mbuffer_append(
1751 &mut self,
1752 accumulator_handle: i32,
1753 data_handle: i32,
1754 ) -> Result<i32, VMHooksEarlyExit> {
1755 match self.handler.mb_append(accumulator_handle, data_handle) {
1756 Ok(_) => Ok(RESULT_OK),
1757 Err(e) => Err(e),
1758 }
1759 }
1760
1761 fn mbuffer_append_bytes(
1762 &mut self,
1763 accumulator_handle: i32,
1764 data_offset: MemPtr,
1765 data_length: MemLength,
1766 ) -> Result<i32, VMHooksEarlyExit> {
1767 unsafe {
1768 let bytes = self.handler.context.memory_load(data_offset, data_length);
1769 match self.handler.mb_append_bytes(accumulator_handle, &bytes) {
1770 Ok(_) => Ok(RESULT_OK),
1771 Err(e) => Err(e),
1772 }
1773 }
1774 }
1775
1776 fn mbuffer_to_big_int_unsigned(
1777 &mut self,
1778 m_buffer_handle: i32,
1779 big_int_handle: i32,
1780 ) -> Result<i32, VMHooksEarlyExit> {
1781 match self
1782 .handler
1783 .mb_to_big_int_unsigned(m_buffer_handle, big_int_handle)
1784 {
1785 Ok(_) => Ok(RESULT_OK),
1786 Err(e) => Err(e),
1787 }
1788 }
1789
1790 fn mbuffer_to_big_int_signed(
1791 &mut self,
1792 m_buffer_handle: i32,
1793 big_int_handle: i32,
1794 ) -> Result<i32, VMHooksEarlyExit> {
1795 match self
1796 .handler
1797 .mb_to_big_int_signed(m_buffer_handle, big_int_handle)
1798 {
1799 Ok(_) => Ok(RESULT_OK),
1800 Err(e) => Err(e),
1801 }
1802 }
1803
1804 fn mbuffer_from_big_int_unsigned(
1805 &mut self,
1806 m_buffer_handle: i32,
1807 big_int_handle: i32,
1808 ) -> Result<i32, VMHooksEarlyExit> {
1809 match self
1810 .handler
1811 .mb_from_big_int_unsigned(m_buffer_handle, big_int_handle)
1812 {
1813 Ok(_) => Ok(RESULT_OK),
1814 Err(e) => Err(e),
1815 }
1816 }
1817
1818 fn mbuffer_from_big_int_signed(
1819 &mut self,
1820 m_buffer_handle: i32,
1821 big_int_handle: i32,
1822 ) -> Result<i32, VMHooksEarlyExit> {
1823 match self
1824 .handler
1825 .mb_from_big_int_signed(m_buffer_handle, big_int_handle)
1826 {
1827 Ok(_) => Ok(RESULT_OK),
1828 Err(e) => Err(e),
1829 }
1830 }
1831
1832 fn mbuffer_to_small_int_unsigned(
1833 &mut self,
1834 m_buffer_handle: i32,
1835 ) -> Result<i64, VMHooksEarlyExit> {
1836 self.handler.mb_to_small_int_unsigned(m_buffer_handle)
1837 }
1838
1839 fn mbuffer_to_small_int_signed(
1840 &mut self,
1841 m_buffer_handle: i32,
1842 ) -> Result<i64, VMHooksEarlyExit> {
1843 self.handler.mb_to_small_int_signed(m_buffer_handle)
1844 }
1845
1846 fn mbuffer_from_small_int_unsigned(
1847 &mut self,
1848 m_buffer_handle: i32,
1849 value: i64,
1850 ) -> Result<(), VMHooksEarlyExit> {
1851 self.handler
1852 .mb_from_small_int_unsigned(m_buffer_handle, value as u64)
1853 }
1854
1855 fn mbuffer_from_small_int_signed(
1856 &mut self,
1857 m_buffer_handle: i32,
1858 value: i64,
1859 ) -> Result<(), VMHooksEarlyExit> {
1860 self.handler
1861 .mb_from_small_int_signed(m_buffer_handle, value)
1862 }
1863
1864 fn mbuffer_to_big_float(
1865 &mut self,
1866 m_buffer_handle: i32,
1867 big_float_handle: i32,
1868 ) -> Result<i32, VMHooksEarlyExit> {
1869 panic!("Unavailable: mbuffer_to_big_float")
1870 }
1871
1872 fn mbuffer_from_big_float(
1873 &mut self,
1874 m_buffer_handle: i32,
1875 big_float_handle: i32,
1876 ) -> Result<i32, VMHooksEarlyExit> {
1877 panic!("Unavailable: mbuffer_from_big_float")
1878 }
1879
1880 fn mbuffer_storage_store(
1881 &mut self,
1882 key_handle: i32,
1883 source_handle: i32,
1884 ) -> Result<i32, VMHooksEarlyExit> {
1885 match self
1886 .handler
1887 .storage_store_managed_buffer_raw(key_handle, source_handle)
1888 {
1889 Ok(_) => Ok(RESULT_OK),
1890 Err(e) => Err(e),
1891 }
1892 }
1893
1894 fn mbuffer_storage_load(
1895 &mut self,
1896 key_handle: i32,
1897 destination_handle: i32,
1898 ) -> Result<i32, VMHooksEarlyExit> {
1899 match self
1900 .handler
1901 .storage_load_managed_buffer_raw(key_handle, destination_handle)
1902 {
1903 Ok(_) => Ok(RESULT_OK),
1904 Err(e) => Err(e),
1905 }
1906 }
1907
1908 fn mbuffer_storage_load_from_address(
1909 &mut self,
1910 address_handle: i32,
1911 key_handle: i32,
1912 destination_handle: i32,
1913 ) -> Result<(), VMHooksEarlyExit> {
1914 self.handler
1915 .storage_load_from_address(address_handle, key_handle, destination_handle)
1916 }
1917
1918 fn mbuffer_get_argument(
1919 &mut self,
1920 id: i32,
1921 destination_handle: i32,
1922 ) -> Result<i32, VMHooksEarlyExit> {
1923 match self
1924 .handler
1925 .load_argument_managed_buffer(id, destination_handle)
1926 {
1927 Ok(_) => Ok(RESULT_OK),
1928 Err(e) => Err(e),
1929 }
1930 }
1931
1932 fn mbuffer_finish(&mut self, source_handle: i32) -> Result<i32, VMHooksEarlyExit> {
1933 match self.handler.finish_managed_buffer_raw(source_handle) {
1934 Ok(_) => Ok(RESULT_OK),
1935 Err(e) => Err(e),
1936 }
1937 }
1938
1939 fn mbuffer_set_random(
1940 &mut self,
1941 destination_handle: i32,
1942 length: i32,
1943 ) -> Result<i32, VMHooksEarlyExit> {
1944 match self
1945 .handler
1946 .mb_set_random(destination_handle, length as usize)
1947 {
1948 Ok(_) => Ok(RESULT_OK),
1949 Err(e) => Err(e),
1950 }
1951 }
1952
1953 fn managed_map_new(&mut self) -> Result<i32, VMHooksEarlyExit> {
1954 Ok(self.handler.mm_new())
1955 }
1956
1957 fn managed_map_put(
1958 &mut self,
1959 map_handle: i32,
1960 key_handle: i32,
1961 value_handle: i32,
1962 ) -> Result<i32, VMHooksEarlyExit> {
1963 self.handler.mm_put(map_handle, key_handle, value_handle);
1964 Ok(RESULT_OK)
1965 }
1966
1967 fn managed_map_get(
1968 &mut self,
1969 map_handle: i32,
1970 key_handle: i32,
1971 out_value_handle: i32,
1972 ) -> Result<i32, VMHooksEarlyExit> {
1973 self.handler
1974 .mm_get(map_handle, key_handle, out_value_handle);
1975 Ok(RESULT_OK)
1976 }
1977
1978 fn managed_map_remove(
1979 &mut self,
1980 map_handle: i32,
1981 key_handle: i32,
1982 out_value_handle: i32,
1983 ) -> Result<i32, VMHooksEarlyExit> {
1984 self.handler
1985 .mm_remove(map_handle, key_handle, out_value_handle);
1986 Ok(RESULT_OK)
1987 }
1988
1989 fn managed_map_contains(
1990 &mut self,
1991 map_handle: i32,
1992 key_handle: i32,
1993 ) -> Result<i32, VMHooksEarlyExit> {
1994 map_bool_to_i32(Ok(self.handler.mm_contains(map_handle, key_handle)))
1995 }
1996
1997 fn small_int_get_unsigned_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
1998 Ok(self.handler.get_argument_u64(id)? as i64)
1999 }
2000
2001 fn small_int_get_signed_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
2002 self.handler.get_argument_i64(id)
2003 }
2004
2005 fn small_int_finish_unsigned(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2006 self.handler.finish_u64(value as u64)
2007 }
2008
2009 fn small_int_finish_signed(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2010 self.handler.finish_i64(value)
2011 }
2012
2013 fn small_int_storage_store_unsigned(
2014 &mut self,
2015 key_offset: MemPtr,
2016 key_length: MemLength,
2017 value: i64,
2018 ) -> Result<i32, VMHooksEarlyExit> {
2019 panic!("Unavailable: small_int_storage_store_unsigned")
2020 }
2021
2022 fn small_int_storage_store_signed(
2023 &mut self,
2024 key_offset: MemPtr,
2025 key_length: MemLength,
2026 value: i64,
2027 ) -> Result<i32, VMHooksEarlyExit> {
2028 panic!("Unavailable: small_int_storage_store_signed")
2029 }
2030
2031 fn small_int_storage_load_unsigned(
2032 &mut self,
2033 key_offset: MemPtr,
2034 key_length: MemLength,
2035 ) -> Result<i64, VMHooksEarlyExit> {
2036 panic!("Unavailable: small_int_storage_load_unsigned")
2037 }
2038
2039 fn small_int_storage_load_signed(
2040 &mut self,
2041 key_offset: MemPtr,
2042 key_length: MemLength,
2043 ) -> Result<i64, VMHooksEarlyExit> {
2044 panic!("Unavailable: small_int_storage_load_signed")
2045 }
2046
2047 fn int64get_argument(&mut self, id: i32) -> Result<i64, VMHooksEarlyExit> {
2048 panic!("Unavailable: int64get_argument")
2049 }
2050
2051 fn int64finish(&mut self, value: i64) -> Result<(), VMHooksEarlyExit> {
2052 panic!("Unavailable: int64finish");
2053 }
2054
2055 fn int64storage_store(
2056 &mut self,
2057 key_offset: MemPtr,
2058 key_length: MemLength,
2059 value: i64,
2060 ) -> Result<i32, VMHooksEarlyExit> {
2061 panic!("Unavailable: int64storage_store")
2062 }
2063
2064 fn int64storage_load(
2065 &mut self,
2066 key_offset: MemPtr,
2067 key_length: MemLength,
2068 ) -> Result<i64, VMHooksEarlyExit> {
2069 panic!("Unavailable: int64storage_load")
2070 }
2071
2072 fn sha256(
2073 &mut self,
2074 data_offset: MemPtr,
2075 length: MemLength,
2076 result_offset: MemPtr,
2077 ) -> Result<i32, VMHooksEarlyExit> {
2078 panic!("Unavailable: sha256")
2079 }
2080
2081 fn managed_sha256(
2082 &mut self,
2083 input_handle: i32,
2084 output_handle: i32,
2085 ) -> Result<i32, VMHooksEarlyExit> {
2086 match self.handler.sha256_managed(output_handle, input_handle) {
2087 Ok(_) => Ok(RESULT_OK),
2088 Err(e) => Err(e),
2089 }
2090 }
2091
2092 fn keccak256(
2093 &mut self,
2094 data_offset: MemPtr,
2095 length: MemLength,
2096 result_offset: MemPtr,
2097 ) -> Result<i32, VMHooksEarlyExit> {
2098 panic!("Unavailable: keccak256")
2099 }
2100
2101 fn managed_keccak256(
2102 &mut self,
2103 input_handle: i32,
2104 output_handle: i32,
2105 ) -> Result<i32, VMHooksEarlyExit> {
2106 match self.handler.keccak256_managed(output_handle, input_handle) {
2107 Ok(_) => Ok(RESULT_OK),
2108 Err(e) => Err(e),
2109 }
2110 }
2111
2112 fn ripemd160(
2113 &mut self,
2114 data_offset: MemPtr,
2115 length: MemLength,
2116 result_offset: MemPtr,
2117 ) -> Result<i32, VMHooksEarlyExit> {
2118 panic!("Unavailable: ripemd160")
2119 }
2120
2121 fn managed_ripemd160(
2122 &mut self,
2123 input_handle: i32,
2124 output_handle: i32,
2125 ) -> Result<i32, VMHooksEarlyExit> {
2126 panic!("Unavailable: managed_ripemd160")
2127 }
2128
2129 fn verify_bls(
2130 &mut self,
2131 key_offset: MemPtr,
2132 message_offset: MemPtr,
2133 message_length: MemLength,
2134 sig_offset: MemPtr,
2135 ) -> Result<i32, VMHooksEarlyExit> {
2136 panic!("Unavailable: verify_bls")
2137 }
2138
2139 fn managed_verify_bls(
2140 &mut self,
2141 key_handle: i32,
2142 message_handle: i32,
2143 sig_handle: i32,
2144 ) -> Result<i32, VMHooksEarlyExit> {
2145 self.handler
2146 .verify_bls_managed(key_handle, message_handle, sig_handle)?;
2147 Ok(0)
2148 }
2149
2150 fn verify_ed25519(
2151 &mut self,
2152 key_offset: MemPtr,
2153 message_offset: MemPtr,
2154 message_length: MemLength,
2155 sig_offset: MemPtr,
2156 ) -> Result<i32, VMHooksEarlyExit> {
2157 panic!("Unavailable: verify_ed25519")
2158 }
2159
2160 fn managed_verify_ed25519(
2161 &mut self,
2162 key_handle: i32,
2163 message_handle: i32,
2164 sig_handle: i32,
2165 ) -> Result<i32, VMHooksEarlyExit> {
2166 match self
2167 .handler
2168 .verify_ed25519_managed(key_handle, message_handle, sig_handle)
2169 {
2170 Ok(_) => Ok(RESULT_OK),
2171 Err(e) => Err(e),
2172 }
2173 }
2174
2175 fn verify_custom_secp256k1(
2176 &mut self,
2177 key_offset: MemPtr,
2178 key_length: MemLength,
2179 message_offset: MemPtr,
2180 message_length: MemLength,
2181 sig_offset: MemPtr,
2182 hash_type: i32,
2183 ) -> Result<i32, VMHooksEarlyExit> {
2184 panic!("Unavailable: verify_custom_secp256k1")
2185 }
2186
2187 fn managed_verify_custom_secp256k1(
2188 &mut self,
2189 key_handle: i32,
2190 message_handle: i32,
2191 sig_handle: i32,
2192 hash_type: i32,
2193 ) -> Result<i32, VMHooksEarlyExit> {
2194 panic!("Unavailable: managed_verify_custom_secp256k1")
2195 }
2196
2197 fn verify_secp256k1(
2198 &mut self,
2199 key_offset: MemPtr,
2200 key_length: MemLength,
2201 message_offset: MemPtr,
2202 message_length: MemLength,
2203 sig_offset: MemPtr,
2204 ) -> Result<i32, VMHooksEarlyExit> {
2205 panic!("Unavailable: verify_secp256k1")
2206 }
2207
2208 fn managed_verify_secp256k1(
2209 &mut self,
2210 key_handle: i32,
2211 message_handle: i32,
2212 sig_handle: i32,
2213 ) -> Result<i32, VMHooksEarlyExit> {
2214 panic!("Unavailable: managed_verify_secp256k1")
2215 }
2216
2217 fn encode_secp256k1_der_signature(
2218 &mut self,
2219 r_offset: MemPtr,
2220 r_length: MemLength,
2221 s_offset: MemPtr,
2222 s_length: MemLength,
2223 sig_offset: MemPtr,
2224 ) -> Result<i32, VMHooksEarlyExit> {
2225 panic!("Unavailable: encode_secp256k1_der_signature")
2226 }
2227
2228 fn managed_encode_secp256k1_der_signature(
2229 &mut self,
2230 r_handle: i32,
2231 s_handle: i32,
2232 sig_handle: i32,
2233 ) -> Result<i32, VMHooksEarlyExit> {
2234 panic!("Unavailable: managed_encode_secp256k1_der_signature")
2235 }
2236
2237 fn add_ec(
2238 &mut self,
2239 x_result_handle: i32,
2240 y_result_handle: i32,
2241 ec_handle: i32,
2242 fst_point_xhandle: i32,
2243 fst_point_yhandle: i32,
2244 snd_point_xhandle: i32,
2245 snd_point_yhandle: i32,
2246 ) -> Result<(), VMHooksEarlyExit> {
2247 panic!("Unavailable: add_ec");
2248 }
2249
2250 fn double_ec(
2251 &mut self,
2252 x_result_handle: i32,
2253 y_result_handle: i32,
2254 ec_handle: i32,
2255 point_xhandle: i32,
2256 point_yhandle: i32,
2257 ) -> Result<(), VMHooksEarlyExit> {
2258 panic!("Unavailable: double_ec");
2259 }
2260
2261 fn is_on_curve_ec(
2262 &mut self,
2263 ec_handle: i32,
2264 point_xhandle: i32,
2265 point_yhandle: i32,
2266 ) -> Result<i32, VMHooksEarlyExit> {
2267 panic!("Unavailable: is_on_curve_ec")
2268 }
2269
2270 fn scalar_base_mult_ec(
2271 &mut self,
2272 x_result_handle: i32,
2273 y_result_handle: i32,
2274 ec_handle: i32,
2275 data_offset: MemPtr,
2276 length: MemLength,
2277 ) -> Result<i32, VMHooksEarlyExit> {
2278 panic!("Unavailable: scalar_base_mult_ec")
2279 }
2280
2281 fn managed_scalar_base_mult_ec(
2282 &mut self,
2283 x_result_handle: i32,
2284 y_result_handle: i32,
2285 ec_handle: i32,
2286 data_handle: i32,
2287 ) -> Result<i32, VMHooksEarlyExit> {
2288 panic!("Unavailable: managed_scalar_base_mult_ec")
2289 }
2290
2291 fn scalar_mult_ec(
2292 &mut self,
2293 x_result_handle: i32,
2294 y_result_handle: i32,
2295 ec_handle: i32,
2296 point_xhandle: i32,
2297 point_yhandle: i32,
2298 data_offset: MemPtr,
2299 length: MemLength,
2300 ) -> Result<i32, VMHooksEarlyExit> {
2301 panic!("Unavailable: scalar_mult_ec")
2302 }
2303
2304 fn managed_scalar_mult_ec(
2305 &mut self,
2306 x_result_handle: i32,
2307 y_result_handle: i32,
2308 ec_handle: i32,
2309 point_xhandle: i32,
2310 point_yhandle: i32,
2311 data_handle: i32,
2312 ) -> Result<i32, VMHooksEarlyExit> {
2313 panic!("Unavailable: managed_scalar_mult_ec")
2314 }
2315
2316 fn marshal_ec(
2317 &mut self,
2318 x_pair_handle: i32,
2319 y_pair_handle: i32,
2320 ec_handle: i32,
2321 result_offset: MemPtr,
2322 ) -> Result<i32, VMHooksEarlyExit> {
2323 panic!("Unavailable: marshal_ec")
2324 }
2325
2326 fn managed_marshal_ec(
2327 &mut self,
2328 x_pair_handle: i32,
2329 y_pair_handle: i32,
2330 ec_handle: i32,
2331 result_handle: i32,
2332 ) -> Result<i32, VMHooksEarlyExit> {
2333 panic!("Unavailable: managed_marshal_ec")
2334 }
2335
2336 fn marshal_compressed_ec(
2337 &mut self,
2338 x_pair_handle: i32,
2339 y_pair_handle: i32,
2340 ec_handle: i32,
2341 result_offset: MemPtr,
2342 ) -> Result<i32, VMHooksEarlyExit> {
2343 panic!("Unavailable: marshal_compressed_ec")
2344 }
2345
2346 fn managed_marshal_compressed_ec(
2347 &mut self,
2348 x_pair_handle: i32,
2349 y_pair_handle: i32,
2350 ec_handle: i32,
2351 result_handle: i32,
2352 ) -> Result<i32, VMHooksEarlyExit> {
2353 panic!("Unavailable: managed_marshal_compressed_ec")
2354 }
2355
2356 fn unmarshal_ec(
2357 &mut self,
2358 x_result_handle: i32,
2359 y_result_handle: i32,
2360 ec_handle: i32,
2361 data_offset: MemPtr,
2362 length: MemLength,
2363 ) -> Result<i32, VMHooksEarlyExit> {
2364 panic!("Unavailable: unmarshal_ec")
2365 }
2366
2367 fn managed_unmarshal_ec(
2368 &mut self,
2369 x_result_handle: i32,
2370 y_result_handle: i32,
2371 ec_handle: i32,
2372 data_handle: i32,
2373 ) -> Result<i32, VMHooksEarlyExit> {
2374 panic!("Unavailable: managed_unmarshal_ec")
2375 }
2376
2377 fn unmarshal_compressed_ec(
2378 &mut self,
2379 x_result_handle: i32,
2380 y_result_handle: i32,
2381 ec_handle: i32,
2382 data_offset: MemPtr,
2383 length: MemLength,
2384 ) -> Result<i32, VMHooksEarlyExit> {
2385 panic!("Unavailable: unmarshal_compressed_ec")
2386 }
2387
2388 fn managed_unmarshal_compressed_ec(
2389 &mut self,
2390 x_result_handle: i32,
2391 y_result_handle: i32,
2392 ec_handle: i32,
2393 data_handle: i32,
2394 ) -> Result<i32, VMHooksEarlyExit> {
2395 panic!("Unavailable: managed_unmarshal_compressed_ec")
2396 }
2397
2398 fn generate_key_ec(
2399 &mut self,
2400 x_pub_key_handle: i32,
2401 y_pub_key_handle: i32,
2402 ec_handle: i32,
2403 result_offset: MemPtr,
2404 ) -> Result<i32, VMHooksEarlyExit> {
2405 panic!("Unavailable: generate_key_ec")
2406 }
2407
2408 fn managed_generate_key_ec(
2409 &mut self,
2410 x_pub_key_handle: i32,
2411 y_pub_key_handle: i32,
2412 ec_handle: i32,
2413 result_handle: i32,
2414 ) -> Result<i32, VMHooksEarlyExit> {
2415 panic!("Unavailable: managed_generate_key_ec")
2416 }
2417
2418 fn create_ec(
2419 &mut self,
2420 data_offset: MemPtr,
2421 data_length: MemLength,
2422 ) -> Result<i32, VMHooksEarlyExit> {
2423 panic!("Unavailable: create_ec")
2424 }
2425
2426 fn managed_create_ec(&mut self, data_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2427 panic!("Unavailable: managed_create_ec")
2428 }
2429
2430 fn get_curve_length_ec(&mut self, ec_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2431 panic!("Unavailable: get_curve_length_ec")
2432 }
2433
2434 fn get_priv_key_byte_length_ec(&mut self, ec_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2435 panic!("Unavailable: get_priv_key_byte_length_ec")
2436 }
2437
2438 fn elliptic_curve_get_values(
2439 &mut self,
2440 ec_handle: i32,
2441 field_order_handle: i32,
2442 base_point_order_handle: i32,
2443 eq_constant_handle: i32,
2444 x_base_point_handle: i32,
2445 y_base_point_handle: i32,
2446 ) -> Result<i32, VMHooksEarlyExit> {
2447 panic!("Unavailable: elliptic_curve_get_values")
2448 }
2449
2450 fn is_reserved_function_name(&mut self, name_handle: i32) -> Result<i32, VMHooksEarlyExit> {
2451 panic!("Unavailable: is_reserved_function_name")
2452 }
2453
2454 fn managed_get_original_caller_addr(
2455 &mut self,
2456 destination_handle: i32,
2457 ) -> Result<(), VMHooksEarlyExit> {
2458 panic!("Unavailable: managed_get_original_caller_addr")
2459 }
2460
2461 fn managed_get_relayer_addr(
2462 &mut self,
2463 destination_handle: i32,
2464 ) -> Result<(), VMHooksEarlyExit> {
2465 panic!("Unavailable: managed_get_relayer_addr")
2466 }
2467
2468 fn managed_multi_transfer_esdt_nft_execute_by_user(
2469 &mut self,
2470 user_handle: i32,
2471 dst_handle: i32,
2472 token_transfers_handle: i32,
2473 gas_limit: i64,
2474 function_handle: i32,
2475 arguments_handle: i32,
2476 ) -> Result<i32, VMHooksEarlyExit> {
2477 panic!("Unavailable: managed_multi_transfer_esdt_nft_execute_by_user")
2478 }
2479
2480 fn managed_verify_secp256r1(
2481 &mut self,
2482 key_handle: i32,
2483 message_handle: i32,
2484 sig_handle: i32,
2485 ) -> Result<i32, VMHooksEarlyExit> {
2486 panic!("Unavailable: managed_verify_secp256r1")
2487 }
2488
2489 fn managed_verify_blssignature_share(
2490 &mut self,
2491 key_handle: i32,
2492 message_handle: i32,
2493 sig_handle: i32,
2494 ) -> Result<i32, VMHooksEarlyExit> {
2495 self.handler
2496 .verify_bls_signature_share(key_handle, message_handle, sig_handle)?;
2497 Ok(0)
2498 }
2499
2500 fn managed_verify_blsaggregated_signature(
2501 &mut self,
2502 key_handle: i32,
2503 message_handle: i32,
2504 sig_handle: i32,
2505 ) -> Result<i32, VMHooksEarlyExit> {
2506 self.handler
2507 .verify_bls_aggregated_signature(key_handle, message_handle, sig_handle)?;
2508 Ok(0)
2509 }
2510}