avm_interface/
call_request_parameters.rs1use super::JValue;
18use crate::CallSeDeErrors;
19
20use air_interpreter_interface::SerializedCallRequests;
21use polyplets::SecurityTetraplet;
22use serde::Deserialize;
23use serde::Serialize;
24
25use std::collections::HashMap;
26
27pub type CallRequests = HashMap<u32, CallRequestParams>;
28
29#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
32pub struct CallRequestParams {
33 pub service_id: String,
35
36 pub function_name: String,
38
39 pub arguments: Vec<JValue>,
41
42 pub tetraplets: Vec<Vec<SecurityTetraplet>>,
44}
45
46impl CallRequestParams {
47 pub fn new(
48 service_id: impl Into<String>,
49 function_name: impl Into<String>,
50 arguments: Vec<JValue>,
51 tetraplets: Vec<Vec<SecurityTetraplet>>,
52 ) -> Self {
53 Self {
54 service_id: service_id.into(),
55 function_name: function_name.into(),
56 arguments,
57 tetraplets,
58 }
59 }
60
61 pub(crate) fn from_raw(
62 call_params: air_interpreter_interface::CallRequestParams,
63 ) -> Result<Self, CallSeDeErrors> {
64 use air_interpreter_interface::CallArgumentsRepr;
65 use air_interpreter_interface::TetrapletsRepr;
66 use air_interpreter_sede::FromSerialized;
67
68 let arguments: Vec<JValue> = CallArgumentsRepr
70 .deserialize(&call_params.arguments)
71 .map_err(|de_error| CallSeDeErrors::CallParamsArgsDeFailed {
72 call_params: call_params.clone(),
73 de_error,
74 })?;
75
76 let tetraplets: Vec<Vec<SecurityTetraplet>> = TetrapletsRepr
77 .deserialize(&call_params.tetraplets)
78 .map_err(|de_error| CallSeDeErrors::CallParamsTetrapletsDeFailed {
79 call_params: call_params.clone(),
80 de_error,
81 })?;
82
83 let call_params = Self {
84 service_id: call_params.service_id,
85 function_name: call_params.function_name,
86 arguments,
87 tetraplets,
88 };
89
90 Ok(call_params)
91 }
92}
93
94pub(crate) fn from_raw_call_requests(
95 raw_call_params: SerializedCallRequests,
96) -> Result<CallRequests, CallSeDeErrors> {
97 use air_interpreter_interface::CallRequestsRepr;
98 use air_interpreter_sede::FromSerialized;
99
100 let call_requests: air_interpreter_interface::CallRequests =
101 match CallRequestsRepr.deserialize(&raw_call_params) {
102 Ok(requests) => requests,
103 Err(error) => {
104 return Err(CallSeDeErrors::CallRequestsDeError {
105 raw_call_request: raw_call_params,
106 error,
107 })
108 .map_err(Into::into)
109 }
110 };
111
112 call_requests
113 .into_iter()
114 .map(|(call_id, call_params)| -> Result<_, _> {
115 let call_params = CallRequestParams::from_raw(call_params)?;
116 Ok((call_id, call_params))
117 })
118 .collect::<Result<_, _>>()
119}