v0.2.3-pre.003

crates/ksp-onchain-transport-lib/src/rpc_transactions.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/src/rpc_transactions.rs
-// version: 2
+// version: 3
 
 /// Binary encoding accepted for serialized transaction input payloads.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
@@ -617,7 +617,6 @@ impl SolanaLatestBlockhash {
     }
 
     /// Decodes a latest-blockhash object from the Solana JSON wire shape.
-    #[cfg(test)]
     pub(crate) fn decode_wire(method: &str, value: serde_json::Value) -> ksp_core_lib::Result<Self> {
         let decoded = crate::decode_wire_json::<WireLatestBlockhash>(method, value);
         let wire = match decoded {
@@ -1103,7 +1102,157 @@ impl SolanaSimulateTransactionResult {
     }
 }
 
-#[cfg(test)]
+impl crate::HttpTransportPool {
+    /// Executes typed `getFeeForMessage` through the common KSP HTTP transport path.
+    pub async fn get_fee_for_message(
+        &self,
+        role: &crate::HttpRoleName,
+        message_base64: &str,
+        config: std::option::Option<&crate::SolanaContextConfig>,
+    ) -> ksp_core_lib::Result<crate::SolanaRpcResponse<std::option::Option<u64>>> {
+        let mut params = std::vec![serde_json::Value::String(message_base64.to_owned())];
+        push_transaction_context_config(&mut params, config);
+        let value = self.execute_transaction_rpc("getFeeForMessage", role, params).await;
+        let value = match value {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let contextual = decode_transaction_contextual_wire("getFeeForMessage", value);
+        let (context, value) = match contextual {
+            std::result::Result::Ok(contextual) => contextual,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let fee = crate::decode_wire_json::<std::option::Option<u64>>("getFeeForMessage", value);
+        return match fee {
+            std::result::Result::Ok(fee) => std::result::Result::Ok(crate::SolanaRpcResponse::new(context, fee)),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+
+    /// Executes typed `getLatestBlockhash` through the common KSP HTTP transport path.
+    pub async fn get_latest_blockhash(
+        &self,
+        role: &crate::HttpRoleName,
+        config: std::option::Option<&crate::SolanaContextConfig>,
+    ) -> ksp_core_lib::Result<crate::SolanaRpcResponse<crate::SolanaLatestBlockhash>> {
+        let mut params = std::vec::Vec::new();
+        push_transaction_context_config(&mut params, config);
+        let value = self.execute_transaction_rpc("getLatestBlockhash", role, params).await;
+        let value = match value {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let contextual = decode_transaction_contextual_wire("getLatestBlockhash", value);
+        let (context, value) = match contextual {
+            std::result::Result::Ok(contextual) => contextual,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let blockhash = crate::SolanaLatestBlockhash::decode_wire("getLatestBlockhash", value);
+        return match blockhash {
+            std::result::Result::Ok(blockhash) => std::result::Result::Ok(crate::SolanaRpcResponse::new(context, blockhash)),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+
+    /// Executes typed `getTransactionCount` through the common KSP HTTP transport path.
+    pub async fn get_transaction_count(
+        &self,
+        role: &crate::HttpRoleName,
+        config: std::option::Option<&crate::SolanaContextConfig>,
+    ) -> ksp_core_lib::Result<u64> {
+        let mut params = std::vec::Vec::new();
+        push_transaction_context_config(&mut params, config);
+        let value = self.execute_transaction_rpc("getTransactionCount", role, params).await;
+        return match value {
+            std::result::Result::Ok(value) => crate::decode_wire_json::<u64>("getTransactionCount", value),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+
+    /// Executes typed `isBlockhashValid` through the common KSP HTTP transport path.
+    pub async fn is_blockhash_valid(
+        &self,
+        role: &crate::HttpRoleName,
+        blockhash: &str,
+        config: std::option::Option<&crate::SolanaContextConfig>,
+    ) -> ksp_core_lib::Result<crate::SolanaRpcResponse<bool>> {
+        let mut params = std::vec![serde_json::Value::String(blockhash.to_owned())];
+        push_transaction_context_config(&mut params, config);
+        let value = self.execute_transaction_rpc("isBlockhashValid", role, params).await;
+        let value = match value {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let contextual = decode_transaction_contextual_wire("isBlockhashValid", value);
+        let (context, value) = match contextual {
+            std::result::Result::Ok(contextual) => contextual,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let valid = crate::decode_wire_json::<bool>("isBlockhashValid", value);
+        return match valid {
+            std::result::Result::Ok(valid) => std::result::Result::Ok(crate::SolanaRpcResponse::new(context, valid)),
+            std::result::Result::Err(error) => std::result::Result::Err(error),
+        };
+    }
+
+    async fn execute_transaction_rpc(
+        &self,
+        method_name: &'static str,
+        role: &crate::HttpRoleName,
+        params: std::vec::Vec<serde_json::Value>,
+    ) -> ksp_core_lib::Result<serde_json::Value> {
+        let method = transaction_descriptor(method_name);
+        let method = match method {
+            std::result::Result::Ok(method) => method,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return self.execute_standard_rpc(role, method, params).await;
+    }
+}
+
+fn push_transaction_context_config(params: &mut std::vec::Vec<serde_json::Value>, config: std::option::Option<&crate::SolanaContextConfig>) {
+    if let std::option::Option::Some(config) = config
+        && (config.commitment().is_some() || config.min_context_slot().is_some())
+    {
+        params.push((*config).to_json_value());
+    }
+    return;
+}
+
+fn decode_transaction_contextual_wire(method: &str, value: serde_json::Value) -> ksp_core_lib::Result<(crate::SolanaRpcContext, serde_json::Value)> {
+    let decoded = crate::decode_wire_json::<WireTransactionRpcResponse>(method, value);
+    let wire = match decoded {
+        std::result::Result::Ok(wire) => wire,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let context = crate::SolanaRpcContext::decode_wire(method, wire.context);
+    return match context {
+        std::result::Result::Ok(context) => std::result::Result::Ok((context, wire.value)),
+        std::result::Result::Err(error) => std::result::Result::Err(error),
+    };
+}
+
+fn transaction_descriptor(method: &str) -> ksp_core_lib::Result<&'static crate::HttpRpcMethodDescriptor> {
+    let descriptor = crate::find_http_rpc_method(method);
+    return match descriptor {
+        std::option::Option::Some(descriptor)
+            if descriptor.category() == crate::HttpRpcCategory::Transactions && descriptor.coverage_release() == crate::HttpRpcCoverageRelease::V0_2_3 =>
+        {
+            std::result::Result::Ok(descriptor)
+        },
+        _ => std::result::Result::Err(
+            ksp_core_lib::Error::new(crate::ERROR_CODE_INVALID_RESPONSE, "typed Transaction descriptor is missing or misclassified in the audited registry")
+                .with_context("rpc_method", method),
+        ),
+    };
+}
+
+#[derive(serde::Deserialize)]
+struct WireTransactionRpcResponse {
+    context: serde_json::Value,
+    value: serde_json::Value,
+}
+
 fn invalid_transaction_wire(method: &str, field: &str, message: &'static str) -> ksp_core_lib::Error {
     return ksp_core_lib::Error::new(crate::ERROR_CODE_INVALID_RESPONSE, message).with_context("rpc_method", method).with_context("field", field);
 }
@@ -1230,7 +1379,6 @@ fn decode_replacement_blockhash_field(
     };
 }
 
-#[cfg(test)]
 #[derive(serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct WireLatestBlockhash {