Deferred calls

Cargo.toml

@@ -76,6 +76,7 @@ massa_consensus_exports = { path = "./massa-consensus-exports" }
 massa_consensus_worker = { path = "./massa-consensus-worker" }
 massa_db_exports = { path = "./massa-db-exports" }
 massa_db_worker = { path = "./massa-db-worker" }
+massa_deferred_calls = { path = "./massa-deferred-calls" }
 massa_executed_ops = { path = "./massa-executed-ops" }
 massa_execution_exports = { path = "./massa-execution-exports" }
 massa_execution_worker = { path = "./massa-execution-worker" }
@@ -106,12 +107,16 @@ massa_versioning = { path = "./massa-versioning" }
 massa_wallet = { path = "./massa-wallet" }
 
 # Massa projects dependencies
-massa-proto-rs = { git = "https://github.com/massalabs/massa-proto-rs", branch = "mainnet_2_3" }
-massa-sc-runtime = { git = "https://github.com/massalabs/massa-sc-runtime", "branch" = "next_breaking_update" }
+# massa-proto-rs = { git = "https://github.com/massalabs/massa-proto-rs", branch = "deferred_calls" }
+# massa-sc-runtime = { git = "https://github.com/massalabs/massa-sc-runtime", "branch" = "deferred_calls" }
+massa-proto-rs = { git = "https://github.com/massalabs/massa-proto-rs", "rev" = "b5267178eaf266ec724691d7de163e4c34343416" }
+massa-sc-runtime = { git = "https://github.com/massalabs/massa-sc-runtime", "rev" = "82dd714d38cbcd863ae0bb215c06442917bb6404" }
+
+
 peernet = { git = "https://github.com/massalabs/PeerNet", "rev" = "04b05ddd320fbe76cc858115af7b5fc28bdb8310" }
 # Dev only - use local dependencies
 # massa-proto-rs = { path = "../massa-proto-rs" }
-# massa-sc-runtime = { path = "../massa-sc-runtime_3" }
+# massa-sc-runtime = { path = "../massa-sc-runtime" }
 # peernet = { path = "../peernet" }
 
 # Common dependencies
@@ -179,7 +184,7 @@ serde = "1.0"
 serde_json = "1.0"
 serde_qs = "0.12"
 serde_with = "3.3"
-serde_yaml = "0.9.34" # 0.9.34+deprecated
+serde_yaml = "0.9.34"                                                                                                    # 0.9.34+deprecated
 serial_test = "2.0"
 sha2 = "=0.10"
 sha3 = "=0.10"

massa-api-exports/Cargo.toml

@@ -22,6 +22,7 @@ massa_final_state = {workspace = true}
 massa_hash = {workspace = true}
 massa_wallet = {workspace = true}
 massa_versioning = {workspace = true}
+massa_deferred_calls = { workspace = true }
 
 [dev-dependencies]
 serial_test = {workspace = true}

massa-api-exports/src/config.rs

@@ -1,5 +1,6 @@
 // Copyright (c) 2022 MASSA LABS <[email protected]>
 
+use massa_deferred_calls::config::DeferredCallsConfig;
 use massa_models::amount::Amount;
 use massa_signature::KeyPair;
 use massa_time::MassaTime;
@@ -84,4 +85,6 @@ pub struct APIConfig {
     pub deferred_credits_delta: MassaTime,
     /// minimal fees to include an operation in a block
     pub minimal_fees: Amount,
+    /// deferred calls config
+    pub deferred_calls_config: DeferredCallsConfig,
 }

massa-api-exports/src/execution.rs

@@ -1,5 +1,6 @@
 // Copyright (c) 2022 MASSA LABS <[email protected]>
 
+use massa_deferred_calls::DeferredCall;
 use massa_final_state::StateChanges;
 use massa_models::{
     address::Address, amount::Amount, block_id::BlockId, operation::OperationId,
@@ -121,3 +122,45 @@ pub struct Transfer {
     /// Context
     pub context: TransferContext,
 }
+
+/// request for deferred call quote
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DeferredCallsQuoteRequest {
+    /// The slot at which the deferred call is to be executed.
+    pub target_slot: Slot,
+    /// The maximum gas requested.
+    pub max_gas_request: u64,
+    /// Size of parameters
+    pub params_size: u64,
+}
+
+/// The response to a request for a deferred call quote.
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DeferredCallsQuoteResponse {
+    /// The slot at which the deferred call is to be executed.
+    pub target_slot: Slot,
+    /// The maximum gas requested.
+    pub max_gas_request: u64,
+    /// if the slot is bookable
+    pub available: bool,
+    /// the cost for booking the call
+    pub price: Amount,
+}
+
+/// response for deferred call
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DeferredCallResponse {
+    /// deferred call id
+    pub call_id: String,
+    /// deferred call
+    pub call: DeferredCall,
+}
+
+/// response for deferred calls by slot
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct DeferredCallsSlotResponse {
+    /// deferred calls
+    pub slot: Slot,
+    /// deferred calls
+    pub call_ids: Vec<String>,
+}

massa-api/src/lib.rs

@@ -11,7 +11,10 @@ use jsonrpsee::proc_macros::rpc;
 use jsonrpsee::server::middleware::http::HostFilterLayer;
 use jsonrpsee::server::{BatchRequestConfig, PingConfig, ServerBuilder, ServerHandle};
 use jsonrpsee::RpcModule;
-use massa_api_exports::execution::Transfer;
+use massa_api_exports::execution::{
+    DeferredCallResponse, DeferredCallsQuoteRequest, DeferredCallsQuoteResponse,
+    DeferredCallsSlotResponse, Transfer,
+};
 use massa_api_exports::{
     address::{AddressFilter, AddressInfo},
     block::{BlockInfo, BlockSummary},
@@ -401,6 +404,27 @@ pub trait MassaRpc {
     /// Get OpenRPC specification.
     #[method(name = "rpc.discover")]
     async fn get_openrpc_spec(&self) -> RpcResult<Value>;
+
+    /// DeferredCall quote
+    #[method(name = "get_deferred_call_quote")]
+    async fn get_deferred_call_quote(
+        &self,
+        arg: Vec<DeferredCallsQuoteRequest>,
+    ) -> RpcResult<Vec<DeferredCallsQuoteResponse>>;
+
+    /// DeferredCall get info
+    #[method(name = "get_deferred_call_info")]
+    async fn get_deferred_call_info(
+        &self,
+        arg: Vec<String>,
+    ) -> RpcResult<Vec<DeferredCallResponse>>;
+
+    /// List deferred calls for given slot
+    #[method(name = "get_deferred_call_ids_by_slot")]
+    async fn get_deferred_call_ids_by_slot(
+        &self,
+        arg: Vec<Slot>,
+    ) -> RpcResult<Vec<DeferredCallsSlotResponse>>;
 }
 
 fn wrong_api<T>() -> RpcResult<T> {

massa-api/src/private.rs

@@ -11,7 +11,11 @@ use massa_api_exports::{
     datastore::{DatastoreEntryInput, DatastoreEntryOutput},
     endorsement::EndorsementInfo,
     error::ApiError,
-    execution::{ExecuteReadOnlyResponse, ReadOnlyBytecodeExecution, ReadOnlyCall, Transfer},
+    execution::{
+        DeferredCallResponse, DeferredCallsQuoteRequest, DeferredCallsQuoteResponse,
+        DeferredCallsSlotResponse, ExecuteReadOnlyResponse, ReadOnlyBytecodeExecution,
+        ReadOnlyCall, Transfer,
+    },
     node::NodeStatus,
     operation::{OperationInfo, OperationInput},
     page::{PageRequest, PagedVec},
@@ -351,6 +355,26 @@ impl MassaRpcServer for API<Private> {
         )
     }
 
+    async fn get_deferred_call_quote(
+        &self,
+        _req: Vec<DeferredCallsQuoteRequest>,
+    ) -> RpcResult<Vec<DeferredCallsQuoteResponse>> {
+        crate::wrong_api::<Vec<DeferredCallsQuoteResponse>>()
+    }
+    async fn get_deferred_call_info(
+        &self,
+        _arg: Vec<String>,
+    ) -> RpcResult<Vec<DeferredCallResponse>> {
+        crate::wrong_api::<Vec<DeferredCallResponse>>()
+    }
+
+    async fn get_deferred_call_ids_by_slot(
+        &self,
+        _slot: Vec<Slot>,
+    ) -> RpcResult<Vec<DeferredCallsSlotResponse>> {
+        crate::wrong_api::<Vec<DeferredCallsSlotResponse>>()
+    }
+
     async fn get_openrpc_spec(&self) -> RpcResult<Value> {
         crate::wrong_api::<Value>()
     }

massa-api/src/public.rs

@@ -13,7 +13,9 @@ use massa_api_exports::{
     endorsement::EndorsementInfo,
     error::ApiError,
     execution::{
-        ExecuteReadOnlyResponse, ReadOnlyBytecodeExecution, ReadOnlyCall, ReadOnlyResult, Transfer,
+        DeferredCallResponse, DeferredCallsQuoteRequest, DeferredCallsQuoteResponse,
+        DeferredCallsSlotResponse, ExecuteReadOnlyResponse, ReadOnlyBytecodeExecution,
+        ReadOnlyCall, ReadOnlyResult, Transfer,
     },
     node::NodeStatus,
     operation::{OperationInfo, OperationInput},
@@ -37,20 +39,17 @@ use massa_models::{
     composite::PubkeySig,
     config::CompactConfig,
     datastore::DatastoreDeserializer,
-    endorsement::EndorsementId,
-    endorsement::SecureShareEndorsement,
+    deferred_calls::DeferredCallId,
+    endorsement::{EndorsementId, SecureShareEndorsement},
     error::ModelsError,
     execution::EventFilter,
     node::NodeId,
-    operation::OperationDeserializer,
-    operation::OperationId,
-    operation::{OperationType, SecureShareOperation},
+    operation::{OperationDeserializer, OperationId, OperationType, SecureShareOperation},
     output_event::SCOutputEvent,
     prehash::{PreHashMap, PreHashSet},
     secure_share::SecureShareDeserializer,
     slot::{IndexedSlot, Slot},
-    timeslots,
-    timeslots::{get_latest_block_slot_at_timestamp, time_range_to_slot_range},
+    timeslots::{self, get_latest_block_slot_at_timestamp, time_range_to_slot_range},
     version::Version,
 };
 use massa_pool_exports::PoolController;
@@ -63,8 +62,8 @@ use massa_versioning::versioning_factory::FactoryStrategy;
 use massa_versioning::{
     keypair_factory::KeyPairFactory, versioning::MipStore, versioning_factory::VersioningFactory,
 };
-use std::collections::BTreeMap;
 use std::net::{IpAddr, SocketAddr};
+use std::{collections::BTreeMap, str::FromStr};
 
 impl API<Public> {
     /// generate a new public API
@@ -1157,6 +1156,132 @@ impl MassaRpcServer for API<Public> {
         Ok(res?)
     }
 
+    async fn get_deferred_call_quote(
+        &self,
+        req: Vec<DeferredCallsQuoteRequest>,
+    ) -> RpcResult<Vec<DeferredCallsQuoteResponse>> {
+        if req.len() as u64 > self.0.api_settings.max_arguments {
+            return Err(ApiError::BadRequest("too many arguments".into()).into());
+        }
+
+        let queries: Vec<ExecutionQueryRequestItem> = req
+            .into_iter()
+            .map(|call| ExecutionQueryRequestItem::DeferredCallQuote {
+                target_slot: call.target_slot,
+                max_gas_request: call.max_gas_request,
+                params_size: call.params_size,
+            })
+            .collect();
+
+        let result = self
+            .0
+            .execution_controller
+            .query_state(ExecutionQueryRequest { requests: queries })
+            .responses
+            .into_iter()
+            .map(|response| match response {
+                Ok(ExecutionQueryResponseItem::DeferredCallQuote(
+                    target_slot,
+                    max_gas_request,
+                    available,
+                    price,
+                )) => Ok(DeferredCallsQuoteResponse {
+                    target_slot,
+                    max_gas_request,
+                    available,
+                    price,
+                }),
+                Ok(_) => Err(ApiError::InternalServerError(
+                    "unexpected response type".to_string(),
+                )),
+                Err(err) => Err(ApiError::InternalServerError(err.to_string())),
+            })
+            .collect::<Result<Vec<DeferredCallsQuoteResponse>, ApiError>>()?;
+
+        Ok(result)
+    }
+
+    async fn get_deferred_call_info(
+        &self,
+        arg: Vec<String>,
+    ) -> RpcResult<Vec<DeferredCallResponse>> {
+        if arg.len() as u64 > self.0.api_settings.max_arguments {
+            return Err(ApiError::BadRequest("too many arguments".into()).into());
+        }
+
+        let requests: Vec<ExecutionQueryRequestItem> = arg
+            .into_iter()
+            .map(|id_str| {
+                DeferredCallId::from_str(&id_str)
+                    .map_err(|e| ApiError::BadRequest(e.to_string()))
+                    .map(ExecutionQueryRequestItem::DeferredCallInfo)
+            })
+            .collect::<Result<_, _>>()?;
+
+        let result: Vec<DeferredCallResponse> = self
+            .0
+            .execution_controller
+            .query_state(ExecutionQueryRequest { requests })
+            .responses
+            .into_iter()
+            .map(|exec| match exec {
+                Ok(ExecutionQueryResponseItem::DeferredCallInfo(id, call)) => {
+                    Ok(DeferredCallResponse {
+                        call_id: id.to_string(),
+                        call,
+                    })
+                }
+                Ok(_) => Err(ApiError::InternalServerError(
+                    "unexpected response type".to_string(),
+                )),
+                Err(err) => Err(ApiError::InternalServerError(err.to_string())),
+            })
+            .collect::<Result<_, _>>()?;
+
+        Ok(result)
+    }
+
+    async fn get_deferred_call_ids_by_slot(
+        &self,
+        slots: Vec<Slot>,
+    ) -> RpcResult<Vec<DeferredCallsSlotResponse>> {
+        if slots.len() as u64 > self.0.api_settings.max_arguments {
+            return Err(ApiError::BadRequest("too many arguments".into()).into());
+        }
+
+        let requests: Vec<ExecutionQueryRequestItem> = slots
+            .into_iter()
+            .map(ExecutionQueryRequestItem::DeferredCallsBySlot)
+            .collect();
+
+        let mut slot_calls = Vec::new();
+
+        for exec in self
+            .0
+            .execution_controller
+            .query_state(ExecutionQueryRequest { requests })
+            .responses
+            .into_iter()
+        {
+            match exec {
+                Ok(ExecutionQueryResponseItem::DeferredCallsBySlot(slot, result)) => {
+                    let call_ids = result.into_iter().map(|id| id.to_string()).collect();
+
+                    slot_calls.push(DeferredCallsSlotResponse { slot, call_ids });
+                }
+                Ok(_) => {
+                    return Err(ApiError::InternalServerError(
+                        "unexpected response type".to_string(),
+                    )
+                    .into())
+                }
+                Err(err) => return Err(ApiError::InternalServerError(err.to_string()).into()),
+            }
+        }
+
+        Ok(slot_calls)
+    }
+
     /// send operations
     async fn send_operations(&self, ops: Vec<OperationInput>) -> RpcResult<Vec<OperationId>> {
         let mut cmd_sender = self.0.pool_command_sender.clone();

massa-api/src/tests/mock.rs

@@ -70,6 +70,7 @@ pub(crate) fn get_apiv2_server(addr: &SocketAddr) -> (API<ApiV2>, APIConfig) {
         chain_id: *CHAINID,
         deferred_credits_delta: MassaTime::from_millis(24 * 3600 * 2),
         minimal_fees: Amount::zero(),
+        deferred_calls_config: Default::default(),
     };
 
     // let shared_storage: massa_storage::Storage = massa_storage::Storage::create_root();
@@ -146,6 +147,7 @@ pub(crate) fn start_public_api(addr: SocketAddr) -> (API<Public>, APIConfig) {
         chain_id: *CHAINID,
         deferred_credits_delta: MassaTime::from_millis(24 * 3600 * 2),
         minimal_fees: Amount::zero(),
+        deferred_calls_config: Default::default(),
     };
 
     let shared_storage: massa_storage::Storage = massa_storage::Storage::create_root();