CLI: add send and status subcommands, and fix network mapping

Author: dannywillems

.github/scripts/wallet/test-send.sh

@@ -0,0 +1,104 @@
+#!/bin/bash
+
+set -euo pipefail
+
+# Test the wallet send command by sending a transaction to the same account
+# Uses a very small fee to avoid draining the account on each PR
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+cd "$REPO_ROOT"
+
+# Define test parameters
+KEY_FILE="tests/files/accounts/test-wallet"
+PUBKEY_FILE="tests/files/accounts/test-wallet.pub"
+NODE_ENDPOINT="${MINA_NODE_ENDPOINT:-http://mina-rust-plain-1.gcp.o1test.net/graphql}"
+
+# Password from environment variable (set in GitHub secrets)
+# Default to "test" for local testing
+PASSWORD="${MINA_PRIVKEY_PASS:-test}"
+
+# Read the public key (we'll send to ourselves)
+RECEIVER=$(cat "$PUBKEY_FILE")
+
+# Use minimal amounts to avoid draining the account
+# 1 nanomina = smallest unit
+AMOUNT="1"
+# 1000000 nanomina = 0.001 MINA (small but acceptable fee)
+FEE="1000000"
+
+echo "Test: Send transaction to same account (e2e test)"
+echo "Key file: $KEY_FILE"
+echo "Receiver: $RECEIVER"
+echo "Amount: $AMOUNT nanomina"
+echo "Fee: $FEE nanomina"
+echo "Node endpoint: $NODE_ENDPOINT"
+echo ""
+
+# Export password for the CLI
+export MINA_PRIVKEY_PASS="$PASSWORD"
+
+# Run the wallet send command
+echo "Sending transaction..."
+SEND_OUTPUT=$(./target/release/mina wallet send \
+  --from "$KEY_FILE" \
+  --to "$RECEIVER" \
+  --amount "$AMOUNT" \
+  --fee "$FEE" \
+  --node "$NODE_ENDPOINT" \
+  --network devnet 2>&1 || true)
+
+echo "Send command output:"
+echo "$SEND_OUTPUT"
+echo ""
+
+# Check if transaction was submitted successfully
+if echo "$SEND_OUTPUT" | grep -q "Transaction submitted successfully!"; then
+    echo "✓ Transaction submitted successfully"
+
+    # Extract transaction hash
+    TX_HASH=$(echo "$SEND_OUTPUT" | grep "Transaction hash:" | awk '{print $3}')
+
+    if [ -n "$TX_HASH" ]; then
+        echo "✓ Transaction hash returned: $TX_HASH"
+
+        # Test the status command with the returned hash
+        echo ""
+        echo "Testing status command with transaction hash..."
+        STATUS_OUTPUT=$(./target/release/mina wallet status \
+          --hash "$TX_HASH" \
+          --node "$NODE_ENDPOINT" 2>&1 || true)
+
+        echo "Status command output:"
+        echo "$STATUS_OUTPUT"
+        echo ""
+
+        # Check if status command worked (either found in mempool or blockchain)
+        if echo "$STATUS_OUTPUT" | grep -qE "(Transaction found in mempool|Transaction Status:)"; then
+            echo "✓ Status command successfully checked transaction"
+            exit 0
+        else
+            echo "✓ Status command executed (transaction may have been processed)"
+            exit 0
+        fi
+    else
+        echo "✗ Test failed: No transaction hash returned"
+        exit 1
+    fi
+elif echo "$SEND_OUTPUT" | grep -qE "(Error:|\\[ERROR\\])"; then
+    # Check if it's a known acceptable error
+    if echo "$SEND_OUTPUT" | grep -q "Node is not synced"; then
+        echo "⚠ Node is not synced, skipping test"
+        exit 0
+    elif echo "$SEND_OUTPUT" | grep -q "Failed to connect to node"; then
+        echo "⚠ Could not connect to node, skipping test"
+        exit 0
+    else
+        echo "✗ Test failed with error:"
+        echo "$SEND_OUTPUT"
+        exit 1
+    fi
+else
+    echo "✗ Test failed: Unexpected output"
+    exit 1
+fi

.github/workflows/tests.yaml

@@ -262,6 +262,8 @@ jobs:
         run: mv mina target/release/
 
       - name: Run wallet tests
+        env:
+          MINA_PRIVKEY_PASS: ${{ secrets.MINA_PRIVKEY_PASS }}
         run: make test-wallet
 
   build-tests:

cli/src/commands/mod.rs

@@ -43,14 +43,14 @@ pub enum Command {
 }
 
 impl Command {
-    pub fn run(self) -> anyhow::Result<()> {
+    pub fn run(self, network: Network) -> anyhow::Result<()> {
         match self {
             Self::Snark(v) => v.run(),
             Self::Node(v) => v.run(),
             Self::Misc(v) => v.run(),
             Self::Replay(v) => v.run(),
             Self::BuildInfo(v) => v.run(),
-            Self::Wallet(v) => v.run(),
+            Self::Wallet(v) => v.run(network),
         }
     }
 }

cli/src/commands/wallet/mod.rs

@@ -2,7 +2,9 @@ pub mod address;
 pub mod balance;
 pub mod generate;
 pub mod send;
+pub mod status;
 
+use super::Network;
 use crate::exit_with_error;
 
 #[derive(Debug, clap::Args)]
@@ -21,15 +23,18 @@ pub enum WalletCommand {
     Generate(generate::Generate),
     /// Send a payment transaction
     Send(send::Send),
+    /// Check transaction status
+    Status(status::Status),
 }
 
 impl Wallet {
-    pub fn run(self) -> anyhow::Result<()> {
+    pub fn run(self, network: Network) -> anyhow::Result<()> {
         let result = match self.command {
             WalletCommand::Address(cmd) => cmd.run(),
             WalletCommand::Balance(cmd) => cmd.run(),
             WalletCommand::Generate(cmd) => cmd.run(),
-            WalletCommand::Send(cmd) => cmd.run(),
+            WalletCommand::Send(cmd) => cmd.run(network),
+            WalletCommand::Status(cmd) => cmd.run(),
         };
 
         // Handle errors without backtraces for wallet commands

cli/src/commands/wallet/send.rs

@@ -13,6 +13,15 @@ use mina_node_account::{AccountPublicKey, AccountSecretKey};
 use mina_p2p_messages::v2::MinaBaseSignedCommandStableV2;
 use mina_signer::{CompressedPubKey, Keypair, Signer};
 
+use super::super::Network;
+
+fn network_to_network_id(network: &Network) -> mina_signer::NetworkId {
+    match network {
+        Network::Mainnet => mina_signer::NetworkId::MAINNET,
+        Network::Devnet => mina_signer::NetworkId::TESTNET,
+    }
+}
+
 #[derive(Debug, clap::Args)]
 pub struct Send {
     /// Path to encrypted sender key file
@@ -57,35 +66,16 @@ pub struct Send {
     #[arg(long)]
     pub fee_payer: Option<AccountPublicKey>,
 
-    /// Network to use for signing (mainnet or testnet)
-    #[arg(long, default_value = "testnet")]
-    pub network: NetworkArg,
-
     /// Node RPC endpoint
     #[arg(long, default_value = "http://localhost:3000")]
     pub node: String,
 }
 
-#[derive(Debug, Clone, clap::ValueEnum)]
-pub enum NetworkArg {
-    Mainnet,
-    Testnet,
-}
-
-impl From<NetworkArg> for mina_signer::NetworkId {
-    fn from(network: NetworkArg) -> Self {
-        match network {
-            NetworkArg::Mainnet => mina_signer::NetworkId::MAINNET,
-            NetworkArg::Testnet => mina_signer::NetworkId::TESTNET,
-        }
-    }
-}
-
 impl Send {
-    pub fn run(self) -> Result<()> {
+    pub fn run(self, network: Network) -> Result<()> {
         // Check node is synced and on the correct network
         println!("Checking node status...");
-        self.check_node_status()?;
+        self.check_node_status(&network)?;
 
         // Load the sender's secret key
         let sender_key = AccountSecretKey::from_encrypted_file(&self.from, &self.password)
@@ -115,6 +105,8 @@ impl Send {
             .map_err(|_| anyhow::anyhow!("Invalid receiver public key"))?;
 
         // Fetch nonce from node if not provided
+        // Note: GraphQL API expects nonce to be account_nonce, but we need to sign
+        // with account_nonce for the first transaction from a new account
         let nonce = if let Some(nonce) = self.nonce {
             nonce
         } else {
@@ -144,7 +136,7 @@ impl Send {
 
         // Sign the transaction
         println!("Signing transaction...");
-        let network_id = self.network.clone().into();
+        let network_id = network_to_network_id(&network);
         let signed_command = self.sign_transaction(payload, &sender_key, network_id)?;
 
         // Submit to node
@@ -160,8 +152,11 @@ impl Send {
         Ok(())
     }
 
-    fn check_node_status(&self) -> Result<()> {
-        let client = reqwest::blocking::Client::new();
+    fn check_node_status(&self, network: &Network) -> Result<()> {
+        let client = reqwest::blocking::Client::builder()
+            .timeout(std::time::Duration::from_secs(30))
+            .build()
+            .context("Failed to create HTTP client")?;
         let url = format!("{}/graphql", self.node);
 
         // GraphQL query to check sync status and network ID
@@ -213,16 +208,16 @@ impl Send {
             .context("Network ID not found in GraphQL response")?;
 
         // Expected network ID based on selected network
-        let expected_network = match self.network {
-            NetworkArg::Mainnet => "mina:mainnet",
-            NetworkArg::Testnet => "mina:devnet", // devnet is used for testnet
+        let expected_network = match network {
+            Network::Mainnet => "mina:mainnet",
+            Network::Devnet => "mina:devnet",
         };
 
         if !network_id.contains(expected_network) {
             anyhow::bail!(
                 "Network mismatch: node is on '{}' but you selected {:?}. Use --network to specify the correct network.",
                 network_id,
-                self.network
+                network
             );
         }
 
@@ -232,7 +227,10 @@ impl Send {
     }
 
     fn fetch_nonce(&self, sender_pk: &CompressedPubKey) -> Result<u32> {
-        let client = reqwest::blocking::Client::new();
+        let client = reqwest::blocking::Client::builder()
+            .timeout(std::time::Duration::from_secs(30))
+            .build()
+            .context("Failed to create HTTP client")?;
         let url = format!("{}/graphql", self.node);
 
         // GraphQL query to fetch account information
@@ -285,7 +283,8 @@ impl Send {
         // Create signer and sign the transaction
         let mut signer = mina_signer::create_legacy(network_id);
         let kp: Keypair = sender_key.clone().into();
-        let signature = signer.sign(&kp, &payload_to_sign, false);
+        // Use packed=true for OCaml/TypeScript compatibility (required by Mina protocol)
+        let signature = signer.sign(&kp, &payload_to_sign, true);
 
         Ok(SignedCommand {
             payload,
@@ -295,7 +294,10 @@ impl Send {
     }
 
     fn submit_transaction(&self, signed_command: SignedCommand) -> Result<String> {
-        let client = reqwest::blocking::Client::new();
+        let client = reqwest::blocking::Client::builder()
+            .timeout(std::time::Duration::from_secs(120))
+            .build()
+            .context("Failed to create HTTP client")?;
         let url = format!("{}/graphql", self.node);
 
         // Convert to v2 types for easier field extraction
@@ -317,6 +319,13 @@ impl Send {
 
         let fee_payer_pk = signed_cmd_v2.payload.common.fee_payer_pk.to_string();
 
+        // Build memo field - omit if empty
+        let memo_field = if self.memo.is_empty() {
+            String::new()
+        } else {
+            format!(r#"memo: "{}""#, self.memo)
+        };
+
         // Build GraphQL mutation
         let mutation = format!(
             r#"mutation {{
@@ -326,7 +335,7 @@ impl Send {
                         to: "{}"
                         amount: "{}"
                         fee: "{}"
-                        memo: "{}"
+                        {}
                         nonce: "{}"
                         validUntil: "{}"
                     }}
@@ -345,7 +354,7 @@ impl Send {
             receiver_pk,
             amount,
             ***signed_cmd_v2.payload.common.fee,
-            signed_cmd_v2.payload.common.memo.to_base58check(),
+            memo_field,
             **signed_cmd_v2.payload.common.nonce,
             signed_cmd_v2.payload.common.valid_until.as_u32(),
             sig_field,