Merge pull request #1119 from 0xMimir/feat/graphql-pooledCommands

Added `pooledUserCommands` and `pooledZkappCommands` graphql endpoint

Author: adonagy

node/common/src/service/rpc/mod.rs

@@ -12,8 +12,9 @@ use node::rpc::{
     RpcDiscoveryBoostrapStatsResponse, RpcDiscoveryRoutingTableResponse, RpcGetBlockResponse,
     RpcHealthCheckResponse, RpcHeartbeatGetResponse, RpcLedgerAccountsResponse,
     RpcLedgerSlimAccountsResponse, RpcMessageProgressResponse, RpcPeersGetResponse,
-    RpcReadinessCheckResponse, RpcRequest, RpcStateGetError, RpcStatusGetResponse,
-    RpcTransactionInjectResponse, RpcTransactionPoolResponse, RpcTransactionStatusGetResponse,
+    RpcPooledUserCommandsResponse, RpcPooledZkappCommandsResponse, RpcReadinessCheckResponse,
+    RpcRequest, RpcStateGetError, RpcStatusGetResponse, RpcTransactionInjectResponse,
+    RpcTransactionPoolResponse, RpcTransactionStatusGetResponse,
     RpcTransitionFrontierUserCommandsResponse,
 };
 use serde::{Deserialize, Serialize};
@@ -309,6 +310,11 @@ impl node::rpc_effectful::RpcService for NodeService {
     );
     rpc_service_impl!(respond_transaction_status, RpcTransactionStatusGetResponse);
     rpc_service_impl!(respond_block_get, RpcGetBlockResponse);
+    rpc_service_impl!(respond_pooled_user_commands, RpcPooledUserCommandsResponse);
+    rpc_service_impl!(
+        respond_pooled_zkapp_commands,
+        RpcPooledZkappCommandsResponse
+    );
 }
 
 #[cfg(test)]

node/native/src/graphql/block.rs

@@ -1,8 +1,8 @@
 use crate::graphql::zkapp::{GraphQLFailureReason, GraphQLFeePayer, GraphQLZkappCommand};
 use juniper::{GraphQLEnum, GraphQLObject};
 use mina_p2p_messages::v2::{
-    MinaBaseSignedCommandPayloadBodyStableV2, MinaBaseStakeDelegationStableV2,
-    TransactionSnarkWorkTStableV2,
+    MinaBaseSignedCommandPayloadBodyStableV2, MinaBaseSignedCommandStableV2,
+    MinaBaseStakeDelegationStableV2, TransactionSnarkWorkTStableV2,
 };
 use openmina_core::block::AppliedBlock;
 
@@ -203,48 +203,7 @@ impl TryFrom<mina_p2p_messages::v2::StagedLedgerDiffDiffDiffStableV2> for GraphQ
         for command in commands {
             match command.data {
                 MinaBaseUserCommandStableV2::SignedCommand(user_command) => {
-                    let is_delegation = matches!(
-                        user_command.payload.body,
-                        MinaBaseSignedCommandPayloadBodyStableV2::StakeDelegation(_)
-                    );
-                    let hash = user_command.hash()?.to_string();
-
-                    let fee = user_command.payload.common.fee.to_string();
-                    let memo = user_command.payload.common.memo.to_base58check();
-                    let nonce = user_command.payload.common.nonce.as_u32() as i32;
-                    let valid_until = user_command.payload.common.valid_until.as_u32().to_string();
-
-                    let (to, amount, kind) = match user_command.payload.body {
-                        MinaBaseSignedCommandPayloadBodyStableV2::Payment(payment) => (
-                            payment.receiver_pk.to_string(),
-                            Some(payment.amount.to_string()),
-                            GraphQLUserCommandsKind::PAYMENT,
-                        ),
-                        MinaBaseSignedCommandPayloadBodyStableV2::StakeDelegation(
-                            MinaBaseStakeDelegationStableV2::SetDelegate { new_delegate },
-                        ) => (
-                            new_delegate.to_string(),
-                            None,
-                            GraphQLUserCommandsKind::STAKE_DELEGATION,
-                        ),
-                    };
-
-                    user_commands.push(GraphQLUserCommands {
-                        hash,
-                        from: user_command.signer.to_string(),
-                        to,
-                        is_delegation,
-                        amount,
-                        failure_reason: Default::default(),
-                        fee,
-                        fee_token: Default::default(),
-                        id: Default::default(),
-                        kind,
-                        memo,
-                        nonce,
-                        token: Default::default(),
-                        valid_until,
-                    });
+                    user_commands.push(GraphQLUserCommands::try_from(user_command)?);
                 }
                 MinaBaseUserCommandStableV2::ZkappCommand(zkapp) => {
                     let failure_reason =
@@ -377,3 +336,53 @@ impl From<&TransactionSnarkWorkTStableV2> for GraphQLSnarkJob {
         }
     }
 }
+
+impl TryFrom<MinaBaseSignedCommandStableV2> for GraphQLUserCommands {
+    type Error = ConversionError;
+
+    fn try_from(user_command: MinaBaseSignedCommandStableV2) -> Result<Self, Self::Error> {
+        let is_delegation = matches!(
+            user_command.payload.body,
+            MinaBaseSignedCommandPayloadBodyStableV2::StakeDelegation(_)
+        );
+        let hash = user_command.hash()?.to_string();
+        let id = user_command.to_base64()?;
+
+        let fee = user_command.payload.common.fee.to_string();
+        let memo = user_command.payload.common.memo.to_base58check();
+        let nonce = user_command.payload.common.nonce.as_u32() as i32;
+        let valid_until = user_command.payload.common.valid_until.as_u32().to_string();
+
+        let (to, amount, kind) = match user_command.payload.body {
+            MinaBaseSignedCommandPayloadBodyStableV2::Payment(payment) => (
+                payment.receiver_pk.to_string(),
+                Some(payment.amount.to_string()),
+                GraphQLUserCommandsKind::PAYMENT,
+            ),
+            MinaBaseSignedCommandPayloadBodyStableV2::StakeDelegation(
+                MinaBaseStakeDelegationStableV2::SetDelegate { new_delegate },
+            ) => (
+                new_delegate.to_string(),
+                None,
+                GraphQLUserCommandsKind::STAKE_DELEGATION,
+            ),
+        };
+
+        Ok(GraphQLUserCommands {
+            hash,
+            from: user_command.signer.to_string(),
+            to,
+            is_delegation,
+            amount,
+            failure_reason: Default::default(),
+            fee,
+            fee_token: Default::default(),
+            id,
+            kind,
+            memo,
+            nonce,
+            token: Default::default(),
+            valid_until,
+        })
+    }
+}

node/native/src/graphql/mod.rs

@@ -1,26 +1,29 @@
-use block::GraphQLBlock;
-use juniper::{graphql_value, FieldError};
-use juniper::{EmptySubscription, GraphQLEnum, RootNode};
+use block::{GraphQLBlock, GraphQLUserCommands};
+use juniper::{graphql_value, EmptySubscription, FieldError, GraphQLEnum, RootNode};
 use ledger::Account;
-use mina_p2p_messages::v2::MinaBaseSignedCommandStableV2;
-use mina_p2p_messages::v2::MinaBaseUserCommandStableV2;
-use mina_p2p_messages::v2::MinaBaseZkappCommandTStableV1WireStableV1;
-use mina_p2p_messages::v2::TokenIdKeyHash;
-use node::rpc::RpcTransactionInjectResponse;
-use node::rpc::{GetBlockQuery, RpcGetBlockResponse, RpcTransactionStatusGetResponse};
+use mina_p2p_messages::v2::{
+    conv, MinaBaseSignedCommandStableV2, MinaBaseUserCommandStableV2,
+    MinaBaseZkappCommandTStableV1WireStableV1, TokenIdKeyHash, TransactionHash,
+};
 use node::{
     account::AccountPublicKey,
-    rpc::{AccountQuery, RpcRequest, RpcSyncStatsGetResponse, SyncStatsQuery},
+    rpc::{
+        AccountQuery, GetBlockQuery, PooledCommandsQuery, RpcGetBlockResponse,
+        RpcPooledUserCommandsResponse, RpcPooledZkappCommandsResponse, RpcRequest,
+        RpcSyncStatsGetResponse, RpcTransactionInjectResponse, RpcTransactionStatusGetResponse,
+        SyncStatsQuery,
+    },
     stats::sync::SyncKind,
 };
 use o1_utils::field_helpers::FieldHelpersError;
-use openmina_core::block::AppliedBlock;
-use openmina_core::consensus::ConsensusConstants;
-use openmina_core::constants::constraint_constants;
+use openmina_core::{
+    block::AppliedBlock, consensus::ConsensusConstants, constants::constraint_constants,
+};
 use openmina_node_common::rpc::RpcSender;
 use std::str::FromStr;
 use transaction::GraphQLTransactionStatus;
 use warp::{Filter, Rejection, Reply};
+use zkapp::GraphQLZkapp;
 
 pub mod account;
 pub mod block;
@@ -51,6 +54,8 @@ pub enum ConversionError {
     SerdeJson(#[from] serde_json::Error),
     #[error("Base58Check: {0}")]
     Base58Check(#[from] mina_p2p_messages::b58::FromBase58CheckError),
+    #[error("Base58 error: {0}")]
+    Base58(#[from] bs58::decode::Error),
     #[error(transparent)]
     InvalidDecimalNumber(#[from] mina_p2p_messages::bigint::InvalidDecimalNumber),
     #[error("Invalid bigint")]
@@ -319,6 +324,73 @@ impl Query {
             Some(Some(block)) => Ok(GraphQLBlock::try_from(block)?),
         }
     }
+
+    /// Retrieve all the scheduled user commands for a specified sender that
+    /// the current daemon sees in its transaction pool. All scheduled
+    /// commands are queried if no sender is specified
+    ///
+    /// Arguments:
+    /// - `public_key`: base58 encoded [`AccountPublicKey`]
+    /// - `hashes`: list of base58 encoded [`TransactionHash`]es
+    /// - `ids`: list of base64 encoded [`MinaBaseZkappCommandTStableV1WireStableV1`]
+    async fn pooled_user_commands(
+        &self,
+        public_key: Option<String>,
+        hashes: Option<Vec<String>>,
+        ids: Option<Vec<String>>,
+        context: &Context,
+    ) -> juniper::FieldResult<Vec<GraphQLUserCommands>> {
+        let query = parse_pooled_commands_query(
+            public_key,
+            hashes,
+            ids,
+            MinaBaseSignedCommandStableV2::from_base64,
+        )?;
+
+        let res: RpcPooledUserCommandsResponse = context
+            .0
+            .oneshot_request(RpcRequest::PooledUserCommands(query))
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+
+        Ok(res
+            .into_iter()
+            .map(GraphQLUserCommands::try_from)
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+
+    /// Retrieve all the scheduled zkApp commands for a specified sender that
+    ///  the current daemon sees in its transaction pool. All scheduled
+    ///  commands are queried if no sender is specified
+    ///
+    /// Arguments:
+    /// - `public_key`: base58 encoded [`AccountPublicKey`]
+    /// - `hashes`: list of base58 encoded [`TransactionHash`]es
+    /// - `ids`: list of base64 encoded [`MinaBaseZkappCommandTStableV1WireStableV1`]
+    async fn pooled_zkapp_commands(
+        public_key: Option<String>,
+        hashes: Option<Vec<String>>,
+        ids: Option<Vec<String>>,
+        context: &Context,
+    ) -> juniper::FieldResult<Vec<GraphQLZkapp>> {
+        let query = parse_pooled_commands_query(
+            public_key,
+            hashes,
+            ids,
+            MinaBaseZkappCommandTStableV1WireStableV1::from_base64,
+        )?;
+
+        let res: RpcPooledZkappCommandsResponse = context
+            .0
+            .oneshot_request(RpcRequest::PooledZkappCommands(query))
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+
+        Ok(res
+            .into_iter()
+            .map(GraphQLZkapp::try_from)
+            .collect::<Result<Vec<_>, _>>()?)
+    }
 }
 
 async fn inject_tx<R>(
@@ -371,6 +443,7 @@ where
         }
     }
 }
+
 #[derive(Clone, Debug)]
 struct Mutation;
 
@@ -488,3 +561,44 @@ pub fn routes(
 //         )))
 //     .or(homepage)
 //     .with(log);
+
+/// Helper function used by [`Query::pooled_user_commands`] and [`Query::pooled_zkapp_commands`] to parse public key, transaction hashes and command ids
+fn parse_pooled_commands_query<ID, F>(
+    public_key: Option<String>,
+    hashes: Option<Vec<String>>,
+    ids: Option<Vec<String>>,
+    id_map_fn: F,
+) -> Result<PooledCommandsQuery<ID>, ConversionError>
+where
+    F: Fn(&str) -> Result<ID, conv::Error>,
+{
+    let public_key = match public_key {
+        Some(public_key) => Some(AccountPublicKey::from_str(&public_key)?),
+        None => None,
+    };
+
+    let hashes = match hashes {
+        Some(hashes) => Some(
+            hashes
+                .into_iter()
+                .map(|tx| TransactionHash::from_str(tx.as_str()))
+                .collect::<Result<Vec<_>, _>>()?,
+        ),
+        None => None,
+    };
+
+    let ids = match ids {
+        Some(ids) => Some(
+            ids.into_iter()
+                .map(|id| id_map_fn(id.as_str()))
+                .collect::<Result<Vec<_>, _>>()?,
+        ),
+        None => None,
+    };
+
+    Ok(PooledCommandsQuery {
+        public_key,
+        hashes,
+        ids,
+    })
+}

node/native/src/graphql/zkapp.rs

@@ -103,29 +103,37 @@ pub struct InputGraphQLZkappCommand {
     pub fee_payer: InputGraphQLFeePayer,
 }
 
+impl TryFrom<MinaBaseZkappCommandTStableV1WireStableV1> for GraphQLZkapp {
+    type Error = ConversionError;
+
+    fn try_from(zkapp: MinaBaseZkappCommandTStableV1WireStableV1) -> Result<Self, Self::Error> {
+        let account_updates = zkapp
+            .account_updates
+            .clone()
+            .into_iter()
+            .map(|v| v.elt.account_update.try_into())
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(GraphQLZkapp {
+            hash: zkapp.hash()?.to_string(),
+            failure_reason: None,
+            id: zkapp.to_base64()?,
+            zkapp_command: GraphQLZkappCommand {
+                memo: zkapp.memo.to_base58check(),
+                account_updates,
+                fee_payer: GraphQLFeePayer::from(zkapp.fee_payer),
+            },
+        })
+    }
+}
+
 impl TryFrom<MinaBaseUserCommandStableV2> for GraphQLSendZkappResponse {
     type Error = ConversionError;
     fn try_from(value: MinaBaseUserCommandStableV2) -> Result<Self, Self::Error> {
         if let MinaBaseUserCommandStableV2::ZkappCommand(zkapp) = value {
-            let account_updates = zkapp
-                .account_updates
-                .clone()
-                .into_iter()
-                .map(|v| v.elt.account_update.try_into())
-                .collect::<Result<Vec<_>, _>>()?;
-            let res = GraphQLSendZkappResponse {
-                zkapp: GraphQLZkapp {
-                    hash: zkapp.hash()?.to_string(),
-                    failure_reason: None,
-                    id: zkapp.to_base64()?,
-                    zkapp_command: GraphQLZkappCommand {
-                        memo: zkapp.memo.to_base58check(),
-                        account_updates,
-                        fee_payer: GraphQLFeePayer::from(zkapp.fee_payer),
-                    },
-                },
-            };
-            Ok(res)
+            Ok(GraphQLSendZkappResponse {
+                zkapp: GraphQLZkapp::try_from(zkapp)?,
+            })
         } else {
             Err(ConversionError::WrongVariant)
         }