feat(graphql): add sendDelegation mutation

Author: Adrian Nagy

node/native/src/graphql/mod.rs

@@ -7,7 +7,6 @@ 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::RpcTransactionInjectedCommand;
 use node::rpc::{GetBlockQuery, RpcGetBlockResponse, RpcTransactionStatusGetResponse};
 use node::{
     account::AccountPublicKey,
@@ -74,6 +73,12 @@ pub enum ConversionError {
     FieldHelpers(#[from] FieldHelpersError),
 }
 
+impl From<ConversionError> for Error {
+    fn from(value: ConversionError) -> Self {
+        Error::Conversion(value)
+    }
+}
+
 struct Context(RpcSender);
 
 impl juniper::Context for Context {}
@@ -316,6 +321,56 @@ impl Query {
     }
 }
 
+async fn inject_tx<R>(
+    cmd: MinaBaseUserCommandStableV2,
+    context: &Context,
+) -> juniper::FieldResult<R>
+where
+    R: TryFrom<MinaBaseUserCommandStableV2>,
+{
+    let res: RpcTransactionInjectResponse = context
+        .0
+        .oneshot_request(RpcRequest::TransactionInject(vec![cmd]))
+        .await
+        .ok_or(Error::StateMachineEmptyResponse)?;
+
+    match res {
+        RpcTransactionInjectResponse::Success(res) => {
+            let cmd: MinaBaseUserCommandStableV2 = match res.first().cloned() {
+                Some(cmd) => cmd.into(),
+                _ => unreachable!(),
+            };
+            cmd.try_into().map_err(|_| {
+                FieldError::new(
+                    "Failed to convert transaction to the required type".to_string(),
+                    graphql_value!(null),
+                )
+            })
+        }
+        RpcTransactionInjectResponse::Rejected(rejected) => {
+            let error_list = rejected
+                .into_iter()
+                .map(|(_, err)| graphql_value!({ "message": err.to_string() }))
+                .collect::<Vec<_>>();
+
+            Err(FieldError::new(
+                "Transaction rejected",
+                graphql_value!(juniper::Value::List(error_list)),
+            ))
+        }
+        RpcTransactionInjectResponse::Failure(failure) => {
+            let error_list = failure
+                .into_iter()
+                .map(|err| graphql_value!({ "message": err.to_string() }))
+                .collect::<Vec<_>>();
+
+            Err(FieldError::new(
+                "Transaction failed",
+                graphql_value!(juniper::Value::List(error_list)),
+            ))
+        }
+    }
+}
 #[derive(Clone, Debug)]
 struct Mutation;
 
@@ -325,50 +380,44 @@ impl Mutation {
         input: zkapp::SendZkappInput,
         context: &Context,
     ) -> juniper::FieldResult<zkapp::GraphQLSendZkappResponse> {
-        let res: RpcTransactionInjectResponse = context
+        inject_tx(input.try_into()?, context).await
+    }
+
+    async fn send_payment(
+        input: user_command::InputGraphQLPayment,
+        signature: user_command::UserCommandSignature,
+        context: &Context,
+    ) -> juniper::FieldResult<user_command::GraphQLSendPaymentResponse> {
+        // Grab the sender's account to get the infered nonce
+        let token_id = TokenIdKeyHash::default();
+        let public_key = AccountPublicKey::from_str(&input.from)
+            .map_err(|e| Error::Conversion(ConversionError::Base58Check(e)))?;
+
+        let accounts: Vec<Account> = context
             .0
-            .oneshot_request(RpcRequest::TransactionInject(vec![input.try_into()?]))
+            .oneshot_request(RpcRequest::LedgerAccountsGet(
+                AccountQuery::PubKeyWithTokenId(public_key, token_id),
+            ))
             .await
             .ok_or(Error::StateMachineEmptyResponse)?;
 
-        match res {
-            RpcTransactionInjectResponse::Success(res) => {
-                let zkapp_cmd: MinaBaseUserCommandStableV2 = match res.first().cloned() {
-                    Some(RpcTransactionInjectedCommand::Zkapp(zkapp_cmd)) => zkapp_cmd.into(),
-                    _ => unreachable!(),
-                };
-                Ok(zkapp_cmd.try_into()?)
-            }
-            RpcTransactionInjectResponse::Rejected(rejected) => {
-                let error_list = rejected
-                    .into_iter()
-                    .map(|(_, err)| graphql_value!({ "message": err.to_string() }))
-                    .collect::<Vec<_>>();
-
-                Err(FieldError::new(
-                    "Transaction rejected",
-                    graphql_value!(juniper::Value::List(error_list)),
-                ))
-            }
-            RpcTransactionInjectResponse::Failure(failure) => {
-                let error_list = failure
-                    .into_iter()
-                    .map(|err| graphql_value!({ "message": err.to_string() }))
-                    .collect::<Vec<_>>();
-
-                Err(FieldError::new(
-                    "Transaction failed",
-                    graphql_value!(juniper::Value::List(error_list)),
-                ))
-            }
-        }
+        let infered_nonce = accounts
+            .first()
+            .ok_or(Error::StateMachineEmptyResponse)?
+            .nonce;
+
+        let command = input
+            .create_user_command(infered_nonce, signature)
+            .map_err(Error::Conversion)?;
+
+        inject_tx(command, context).await
     }
 
-    async fn send_payment(
-        input: user_command::InputGraphQLPayment,
+    async fn send_delegation(
+        input: user_command::InputGraphQLDelegation,
         signature: user_command::UserCommandSignature,
         context: &Context,
-    ) -> juniper::FieldResult<user_command::GraphQLSendPaymentResponse> {
+    ) -> juniper::FieldResult<user_command::GraphQLSendDelegationResponse> {
         // Payment commands are always for the default (MINA) token
         let token_id = TokenIdKeyHash::default();
         let public_key = AccountPublicKey::from_str(&input.from)?;
@@ -388,43 +437,7 @@ impl Mutation {
             .nonce;
         let command = input.create_user_command(infered_nonce, signature)?;
 
-        let res: RpcTransactionInjectResponse = context
-            .0
-            .oneshot_request(RpcRequest::TransactionInject(vec![command]))
-            .await
-            .ok_or(Error::StateMachineEmptyResponse)?;
-
-        match res {
-            RpcTransactionInjectResponse::Success(res) => {
-                let payment_cmd: MinaBaseUserCommandStableV2 = match res.first().cloned() {
-                    Some(RpcTransactionInjectedCommand::Payment(payment)) => payment.into(),
-                    _ => unreachable!(),
-                };
-                Ok(payment_cmd.try_into()?)
-            }
-            RpcTransactionInjectResponse::Rejected(rejected) => {
-                let error_list = rejected
-                    .into_iter()
-                    .map(|(_, err)| graphql_value!({ "message": err.to_string() }))
-                    .collect::<Vec<_>>();
-
-                Err(FieldError::new(
-                    "Transaction rejected",
-                    graphql_value!(juniper::Value::List(error_list)),
-                ))
-            }
-            RpcTransactionInjectResponse::Failure(failure) => {
-                let error_list = failure
-                    .into_iter()
-                    .map(|err| graphql_value!({ "message": err.to_string() }))
-                    .collect::<Vec<_>>();
-
-                Err(FieldError::new(
-                    "Transaction failed",
-                    graphql_value!(juniper::Value::List(error_list)),
-                ))
-            }
-        }
+        inject_tx(command, context).await
     }
 }
 

node/native/src/graphql/user_command.rs

@@ -32,6 +32,16 @@ pub struct InputGraphQLPayment {
     pub nonce: Option<String>,
 }
 
+#[derive(GraphQLInputObject, Debug)]
+pub struct InputGraphQLDelegation {
+    pub from: String,
+    pub to: String,
+    pub valid_until: Option<String>,
+    pub fee: String,
+    pub memo: Option<String>,
+    pub nonce: Option<String>,
+}
+
 #[derive(GraphQLInputObject, Debug, Clone)]
 pub struct UserCommandSignature {
     pub field: Option<String>,
@@ -108,6 +118,11 @@ pub struct GraphQLSendPaymentResponse {
     pub payment: GraphQLUserCommand,
 }
 
+#[derive(GraphQLObject, Debug)]
+pub struct GraphQLSendDelegationResponse {
+    pub delegation: GraphQLUserCommand,
+}
+
 #[derive(GraphQLObject, Debug)]
 pub struct GraphQLUserCommand {
     pub amount: String,
@@ -147,7 +162,7 @@ impl TryFrom<v2::MinaBaseUserCommandStableV2> for GraphQLSendPaymentResponse {
                         hash: signed_cmd.hash()?.to_string(),
                         id: signed_cmd.to_base64()?,
                         is_delegation: false,
-                        kind: "Payment".to_string(),
+                        kind: "PAYMENT".to_string(),
                         memo: signed_cmd.payload.common.memo.to_base58check(),
                         nonce: signed_cmd.payload.common.nonce.to_string(),
                         receiver: payment.receiver_pk.to_string(),
@@ -166,6 +181,43 @@ impl TryFrom<v2::MinaBaseUserCommandStableV2> for GraphQLSendPaymentResponse {
     }
 }
 
+impl TryFrom<v2::MinaBaseUserCommandStableV2> for GraphQLSendDelegationResponse {
+    type Error = super::ConversionError;
+    fn try_from(value: v2::MinaBaseUserCommandStableV2) -> Result<Self, Self::Error> {
+        if let v2::MinaBaseUserCommandStableV2::SignedCommand(ref signed_cmd) = value {
+            if let v2::MinaBaseSignedCommandPayloadBodyStableV2::StakeDelegation(ref delegation) =
+                signed_cmd.payload.body
+            {
+                let v2::MinaBaseStakeDelegationStableV2::SetDelegate { new_delegate } = delegation;
+                let res = GraphQLSendDelegationResponse {
+                    delegation: GraphQLUserCommand {
+                        amount: "0".to_string(),
+                        fee: signed_cmd.payload.common.fee.to_string(),
+                        failure_reason: None,
+                        fee_payer: signed_cmd.payload.common.fee_payer_pk.to_string(),
+                        fee_token: TokenIdKeyHash::default().to_string(),
+                        hash: signed_cmd.hash()?.to_string(),
+                        id: signed_cmd.to_base64()?,
+                        is_delegation: true,
+                        kind: "STAKE_DELEGATION".to_string(),
+                        memo: signed_cmd.payload.common.memo.to_base58check(),
+                        nonce: signed_cmd.payload.common.nonce.to_string(),
+                        receiver: new_delegate.to_string(),
+                        source: signed_cmd.payload.common.fee_payer_pk.to_string(),
+                        token: TokenIdKeyHash::default().to_string(),
+                        valid_until: signed_cmd.payload.common.valid_until.as_u32().to_string(),
+                    },
+                };
+                Ok(res)
+            } else {
+                Err(super::ConversionError::WrongVariant)
+            }
+        } else {
+            Err(super::ConversionError::WrongVariant)
+        }
+    }
+}
+
 impl InputGraphQLPayment {
     pub fn create_user_command(
         &self,
@@ -244,11 +296,79 @@ impl InputGraphQLPayment {
         Ok(v2::MinaBaseUserCommandStableV2::SignedCommand(sc.into()))
     }
 }
-// impl TryFrom<InputGraphQLSendPayment> for v2::MinaBaseUserCommandStableV2 {
-//     type Error = super::ConversionError;
 
-//     fn try_from(value: InputGraphQLSendPayment) -> Result<Self, Self::Error> {
-//         let InputGraphQLSendPayment { input, signature } = value;
+impl InputGraphQLDelegation {
+    pub fn create_user_command(
+        &self,
+        infered_nonce: Nonce,
+        signature: UserCommandSignature,
+    ) -> Result<v2::MinaBaseUserCommandStableV2, super::ConversionError> {
+        let infered_nonce = infered_nonce.incr();
 
-//     }
-// }
+        let nonce = if let Some(nonce) = &self.nonce {
+            let input_nonce = Nonce::from_u32(
+                nonce
+                    .parse::<u32>()
+                    .map_err(|_| super::ConversionError::InvalidBigInt)?,
+            );
+
+            if input_nonce.is_zero() || input_nonce > infered_nonce {
+                return Err(super::ConversionError::Custom(
+                    "Provided nonce is zero or greater than infered nonce".to_string(),
+                ));
+            } else {
+                input_nonce
+            }
+        } else {
+            infered_nonce
+        };
+
+        let valid_until = if let Some(valid_until) = &self.valid_until {
+            Some(Slot::from_u32(
+                valid_until
+                    .parse::<u32>()
+                    .map_err(|_| super::ConversionError::InvalidBigInt)?,
+            ))
+        } else {
+            None
+        };
+
+        let memo = if let Some(memo) = &self.memo {
+            Memo::from_str(memo)
+                .map_err(|_| super::ConversionError::Custom("Invalid memo".to_string()))?
+        } else {
+            Memo::empty()
+        };
+
+        let from: CompressedPubKey = AccountPublicKey::from_str(&self.from)?
+            .try_into()
+            .map_err(|_| super::ConversionError::InvalidBigInt)?;
+
+        let signature = signature.try_into()?;
+
+        let sc: signed_command::SignedCommand = signed_command::SignedCommand {
+            payload: signed_command::SignedCommandPayload::create(
+                Fee::from_u64(
+                    self.fee
+                        .parse::<u64>()
+                        .map_err(|_| super::ConversionError::InvalidBigInt)?,
+                ),
+                from.clone(),
+                nonce,
+                valid_until,
+                memo,
+                signed_command::Body::StakeDelegation(
+                    signed_command::StakeDelegationPayload::SetDelegate {
+                        new_delegate: AccountPublicKey::from_str(&self.to)?
+                            .try_into()
+                            .map_err(|_| super::ConversionError::InvalidBigInt)?,
+                    },
+                ),
+            ),
+            signer: from.clone(),
+            signature,
+        };
+
+        Ok(v2::MinaBaseUserCommandStableV2::SignedCommand(sc.into()))
+    }
+}