feat: Add account details endpoint

Makefile.toml

@@ -49,7 +49,7 @@ args = ["-rf", "miden-node"]
 description = "Clone or update miden-node repository and clean up files"
 script_runner = "bash"
 script = [
-    'if [ -d miden-node ]; then cd miden-node && git pull ; else git clone --branch next https://github.com/0xPolygonMiden/miden-node.git && cd miden-node; fi',
+    'if [ -d miden-node ]; then cd miden-node && git checkout next && git pull origin next; else git clone --branch next https://github.com/0xPolygonMiden/miden-node.git && cd miden-node; fi',
     'rm -rf miden-store.sqlite3 miden-store.sqlite3-wal miden-store.sqlite3-shm',
     'cargo run --bin $NODE_BINARY --features $NODE_FEATURES_TESTING -- make-genesis --inputs-path node/genesis.toml --force'
 ]

clippy.toml

@@ -1 +1,2 @@
 large-error-threshold = 256
+too-many-arguments-threshold = 8

src/cli/account.rs

@@ -1,6 +1,6 @@
 use std::{fs, path::PathBuf};
 
-use clap::Parser;
+use clap::{Parser, ValueEnum};
 use comfy_table::{presets, Attribute, Cell, ContentArrangement, Table};
 use miden_client::{
     client::{accounts, rpc::NodeRpcClient, Client},
@@ -61,9 +61,15 @@ pub enum AccountCmd {
 #[clap()]
 pub enum AccountTemplate {
     /// Creates a basic account (Regular account with immutable code)
-    BasicImmutable,
+    BasicImmutable {
+        #[clap(short, long, value_enum, default_value_t = AccountStorageMode::OffChain)]
+        storage_mode: AccountStorageMode,
+    },
     /// Creates a basic account (Regular account with mutable code)
-    BasicMutable,
+    BasicMutable {
+        #[clap(short, long, value_enum, default_value_t = AccountStorageMode::OffChain)]
+        storage_mode: AccountStorageMode,
+    },
     /// Creates a faucet for fungible tokens
     FungibleFaucet {
         #[clap(short, long)]
@@ -72,9 +78,35 @@ pub enum AccountTemplate {
         decimals: u8,
         #[clap(short, long)]
         max_supply: u64,
+        #[clap(short, long, value_enum, default_value_t = AccountStorageMode::OffChain)]
+        storage_mode: AccountStorageMode,
     },
     /// Creates a faucet for non-fungible tokens
-    NonFungibleFaucet,
+    NonFungibleFaucet {
+        #[clap(short, long, value_enum, default_value_t = AccountStorageMode::OffChain)]
+        storage_mode: AccountStorageMode,
+    },
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+pub enum AccountStorageMode {
+    OffChain,
+    OnChain,
+}
+
+impl From<AccountStorageMode> for accounts::AccountStorageMode {
+    fn from(value: AccountStorageMode) -> Self {
+        match value {
+            AccountStorageMode::OffChain => accounts::AccountStorageMode::Local,
+            AccountStorageMode::OnChain => accounts::AccountStorageMode::OnChain,
+        }
+    }
+}
+
+impl From<&AccountStorageMode> for accounts::AccountStorageMode {
+    fn from(value: &AccountStorageMode) -> Self {
+        accounts::AccountStorageMode::from(*value)
+    }
 }
 
 impl AccountCmd {
@@ -88,26 +120,31 @@ impl AccountCmd {
             },
             AccountCmd::New { template } => {
                 let client_template = match template {
-                    AccountTemplate::BasicImmutable => accounts::AccountTemplate::BasicWallet {
-                        mutable_code: false,
-                        storage_mode: accounts::AccountStorageMode::Local,
+                    AccountTemplate::BasicImmutable { storage_mode } => {
+                        accounts::AccountTemplate::BasicWallet {
+                            mutable_code: false,
+                            storage_mode: storage_mode.into(),
+                        }
                     },
-                    AccountTemplate::BasicMutable => accounts::AccountTemplate::BasicWallet {
-                        mutable_code: true,
-                        storage_mode: accounts::AccountStorageMode::Local,
+                    AccountTemplate::BasicMutable { storage_mode } => {
+                        accounts::AccountTemplate::BasicWallet {
+                            mutable_code: true,
+                            storage_mode: storage_mode.into(),
+                        }
                     },
                     AccountTemplate::FungibleFaucet {
                         token_symbol,
                         decimals,
                         max_supply,
+                        storage_mode,
                     } => accounts::AccountTemplate::FungibleFaucet {
                         token_symbol: TokenSymbol::new(token_symbol)
                             .map_err(|err| format!("error: token symbol is invalid: {}", err))?,
                         decimals: *decimals,
                         max_supply: *max_supply,
-                        storage_mode: accounts::AccountStorageMode::Local,
+                        storage_mode: storage_mode.into(),
                     },
-                    AccountTemplate::NonFungibleFaucet => todo!(),
+                    AccountTemplate::NonFungibleFaucet { storage_mode: _ } => todo!(),
                 };
                 let (_new_account, _account_seed) = client.new_account(client_template)?;
             },

src/client/accounts.rs

@@ -30,11 +30,21 @@ pub enum AccountTemplate {
     },
 }
 
+#[derive(Debug, Clone, Copy)]
 pub enum AccountStorageMode {
     Local,
     OnChain,
 }
 
+impl From<AccountStorageMode> for AccountStorageType {
+    fn from(mode: AccountStorageMode) -> Self {
+        match mode {
+            AccountStorageMode::Local => AccountStorageType::OffChain,
+            AccountStorageMode::OnChain => AccountStorageType::OnChain,
+        }
+    }
+}
+
 impl<N: NodeRpcClient, R: FeltRng, S: Store> Client<N, R, S> {
     // ACCOUNT CREATION
     // --------------------------------------------------------------------------------------------
@@ -108,20 +118,11 @@ impl<N: NodeRpcClient, R: FeltRng, S: Store> Client<N, R, S> {
     }
 
     /// Creates a new regular account and saves it in the store along with its seed and auth data
-    ///
-    /// # Panics
-    ///
-    /// If the passed [AccountStorageMode] is [AccountStorageMode::OnChain], this function panics
-    /// since this feature is not currently supported on Miden
     fn new_basic_wallet(
         &mut self,
         mutable_code: bool,
         account_storage_mode: AccountStorageMode,
     ) -> Result<(Account, Word), ClientError> {
-        if let AccountStorageMode::OnChain = account_storage_mode {
-            todo!("Recording the account on chain is not supported yet");
-        }
-
         // TODO: This should be initialized with_rng
         let key_pair = SecretKey::new();
 
@@ -138,14 +139,14 @@ impl<N: NodeRpcClient, R: FeltRng, S: Store> Client<N, R, S> {
                 init_seed,
                 auth_scheme,
                 AccountType::RegularAccountImmutableCode,
-                AccountStorageType::OffChain,
+                account_storage_mode.into(),
             )
         } else {
             miden_lib::accounts::wallets::create_basic_wallet(
                 init_seed,
                 auth_scheme,
                 AccountType::RegularAccountUpdatableCode,
-                AccountStorageType::OffChain,
+                account_storage_mode.into(),
             )
         }?;
 
@@ -160,10 +161,6 @@ impl<N: NodeRpcClient, R: FeltRng, S: Store> Client<N, R, S> {
         max_supply: u64,
         account_storage_mode: AccountStorageMode,
     ) -> Result<(Account, Word), ClientError> {
-        if let AccountStorageMode::OnChain = account_storage_mode {
-            todo!("On-chain accounts are not supported yet");
-        }
-
         // TODO: This should be initialized with_rng
         let key_pair = SecretKey::new();
 
@@ -181,7 +178,7 @@ impl<N: NodeRpcClient, R: FeltRng, S: Store> Client<N, R, S> {
             decimals,
             Felt::try_from(max_supply.to_le_bytes().as_slice())
                 .expect("u64 can be safely converted to a field element"),
-            AccountStorageType::OffChain,
+            account_storage_mode.into(),
             auth_scheme,
         )?;
 

src/client/rpc/mod.rs

@@ -2,7 +2,7 @@ use core::fmt;
 
 use async_trait::async_trait;
 use miden_objects::{
-    accounts::AccountId,
+    accounts::{Account, AccountId},
     crypto::merkle::{MerklePath, MmrDelta},
     notes::{NoteId, NoteMetadata},
     transaction::ProvenTransaction,
@@ -56,6 +56,11 @@ pub trait NodeRpcClient {
         note_tags: &[u16],
         nullifiers_tags: &[u16],
     ) -> Result<StateSyncInfo, NodeRpcClientError>;
+
+    async fn get_account_update(
+        &mut self,
+        account_id: AccountId,
+    ) -> Result<Option<Account>, NodeRpcClientError>;
 }
 
 // STATE SYNC INFO
@@ -130,6 +135,7 @@ impl CommittedNote {
 //
 #[derive(Debug)]
 pub enum NodeRpcClientEndpoint {
+    GetAccountDetails,
     GetBlockHeaderByNumber,
     SyncState,
     SubmitProvenTx,
@@ -141,6 +147,7 @@ impl fmt::Display for NodeRpcClientEndpoint {
         f: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         match self {
+            NodeRpcClientEndpoint::GetAccountDetails => write!(f, "get_account_details"),
             NodeRpcClientEndpoint::GetBlockHeaderByNumber => {
                 write!(f, "get_block_header_by_number")
             },

src/client/rpc/tonic_client.rs

@@ -3,16 +3,18 @@ use miden_node_proto::{
     errors::ConversionError,
     generated::{
         requests::{
-            GetBlockHeaderByNumberRequest, SubmitProvenTransactionRequest, SyncStateRequest,
+            GetAccountDetailsRequest, GetBlockHeaderByNumberRequest,
+            SubmitProvenTransactionRequest, SyncStateRequest,
         },
         responses::SyncStateResponse,
         rpc::api_client::ApiClient,
     },
 };
 use miden_objects::{
-    accounts::AccountId,
+    accounts::{Account, AccountId},
     notes::{NoteId, NoteMetadata, NoteType},
     transaction::ProvenTransaction,
+    utils::Deserializable,
     BlockHeader, Digest,
 };
 use miden_tx::utils::Serializable;
@@ -127,6 +129,37 @@ impl NodeRpcClient for TonicRpcClient {
         })?;
         response.into_inner().try_into()
     }
+
+    /// TODO: fill description
+    async fn get_account_update(
+        &mut self,
+        account_id: AccountId,
+    ) -> Result<Option<Account>, NodeRpcClientError> {
+        debug_assert!(account_id.is_on_chain());
+
+        let account_id = account_id.into();
+        let request = GetAccountDetailsRequest {
+            account_id: Some(account_id),
+        };
+
+        let rpc_api = self.rpc_api().await?;
+
+        let response = rpc_api.get_account_details(request).await.map_err(|err| {
+            NodeRpcClientError::RequestError(
+                NodeRpcClientEndpoint::GetAccountDetails.to_string(),
+                err.to_string(),
+            )
+        })?;
+        let response = response.into_inner();
+        // TODO: remove unwrap and use proper handling
+        let account_info = response.account.unwrap();
+        let details = account_info
+            .details
+            .map(|details| Account::read_from_bytes(&details))
+            .transpose()?;
+
+        Ok(details)
+    }
 }
 
 // STATE SYNC INFO CONVERSION