clippy

Author: Gleb

FULL_HELP_DOCS.md

@@ -55,6 +55,7 @@ Anything after the `--` double dash (the "slop") is parsed as arguments to the c
 * `completion` — Print shell completion code for the specified shell
 * `cache` — Cache for transactions and contract specs
 * `version` — Print version information
+* `ledger` — Fetch ledger information
 
 ###### **Options:**
 
@@ -2663,3 +2664,79 @@ Print version information
 
 
 
+## `stellar ledger`
+
+Fetch ledger information
+
+**Usage:** `stellar ledger <COMMAND>`
+
+###### **Subcommands:**
+
+* `entry` — Work with ledger entries
+
+
+
+## `stellar ledger entry`
+
+Work with ledger entries
+
+**Usage:** `stellar ledger entry <COMMAND>`
+
+###### **Subcommands:**
+
+* `get` — Get ledger entries. This command supports every type of ledger entries supported by the RPC. Read more about RPC command here: https://developers.stellar.org/docs/data/apis/rpc/api-reference/methods/getLedgerEntries#types-of-ledgerkeys
+
+
+
+## `stellar ledger entry get`
+
+Get ledger entries. This command supports every type of ledger entries supported by the RPC. Read more about RPC command here: https://developers.stellar.org/docs/data/apis/rpc/api-reference/methods/getLedgerEntries#types-of-ledgerkeys
+
+**Usage:** `stellar ledger entry get [OPTIONS]`
+
+###### **Options:**
+
+* `--rpc-url <RPC_URL>` — RPC server endpoint
+* `--rpc-header <RPC_HEADERS>` — RPC Header(s) to include in requests to the RPC provider
+* `--network-passphrase <NETWORK_PASSPHRASE>` — Network passphrase to sign the transaction sent to the rpc server
+* `-n`, `--network <NETWORK>` — Name of network to use from config
+* `--global` — Use global config
+* `--config-dir <CONFIG_DIR>` — Location of config directory, default is "."
+* `--account <ACCOUNT>` — Name of identity to lookup, default is test identity
+* `--hd-path <HD_PATH>` — If identity is a seed phrase use this hd path, default is 0
+* `--asset <ASSET>` — Assets to get trustline info for
+* `--offer <OFFER>` — ID of an offer made on the Stellar DEX
+* `--data-name <DATA_NAME>` — Fetch key-value data entries attached to an account (see manageDataOp)
+* `--claimable-id <CLAIMABLE_ID>` — Claimable Balance id
+* `--pool-id <POOL_ID>` — Liquidity pool id
+* `--config-setting-id <CONFIG_SETTING_ID>` — Defines the currently active network configuration
+* `--wasm-hash <WASM_HASH>` — Get WASM bytecode by hash
+* `--ttl <TTL>` — Get the time-to-live of an associated contract data or code entry
+* `--id <CONTRACT_ID>` — Contract id to fetch an info for
+* `--durability <DURABILITY>` — Storage entry durability
+
+  Default value: `persistent`
+
+  Possible values:
+  - `persistent`:
+    Persistent
+  - `temporary`:
+    Temporary
+
+* `--key <KEY>` — Storage key (symbols only)
+* `--key-xdr <KEY_XDR>` — Storage key (base64-encoded XDR)
+* `--output <OUTPUT>` — Format of the output
+
+  Default value: `original`
+
+  Possible values:
+  - `original`:
+    Original RPC output (containing XDRs)
+  - `json`:
+    JSON output of the ledger entry with parsed XDRs (one line, not formatted)
+  - `json-formatted`:
+    Formatted (multiline) JSON output of the ledger entry with parsed XDRs
+
+
+
+

cmd/soroban-cli/src/commands/ledger/entry/get.rs

@@ -22,6 +22,7 @@ use stellar_xdr::curr::{
     LedgerKeyLiquidityPool, LedgerKeyOffer, LedgerKeyTrustLine, LedgerKeyTtl, Limits, MuxedAccount,
     PoolId, PublicKey, ReadXdr, ScAddress, ScVal, String64, TrustLineAsset, Uint256,
 };
+use crate::config::network::Network;
 
 #[derive(Parser, Debug, Clone)]
 #[group(skip)]
@@ -139,55 +140,95 @@ impl Cmd {
         let client = network.rpc_client()?;
         let mut ledger_keys = vec![];
 
-        if let Some(contract_id) = &self.contract_id {
-            let contract_id =
-                contract_id.resolve_contract_id(&self.locator, &network.network_passphrase)?;
+        self.insert_contract_keys(&network, &mut ledger_keys)?;
 
-            let contract_address_arg = ScAddress::Contract(Hash(contract_id.0));
+        self.insert_accpount_keys(&mut ledger_keys)?;
 
-            if let Some(keys) = &self.key {
-                for key in keys {
-                    let key = LedgerKey::ContractData(LedgerKeyContractData {
-                        contract: contract_address_arg.clone(),
-                        key: soroban_spec_tools::from_string_primitive(
-                            key,
-                            &xdr::ScSpecTypeDef::Symbol,
-                        )?,
-                        durability: ContractDataDurability::Persistent,
-                    });
+        if let Some(claimable_id) = &self.claimable_id {
+            for x in claimable_id {
+                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
+                let key = LedgerKey::ClaimableBalance(LedgerKeyClaimableBalance {
+                    balance_id: ClaimableBalanceIdTypeV0(hash),
+                });
+                ledger_keys.push(key);
+            }
+        }
 
-                    ledger_keys.push(key);
-                }
+        if let Some(pool_id) = &self.pool_id {
+            for x in pool_id {
+                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
+                let key = LedgerKey::LiquidityPool(LedgerKeyLiquidityPool {
+                    liquidity_pool_id: PoolId(hash),
+                });
+                ledger_keys.push(key);
             }
+        }
 
-            if let Some(keys) = &self.key_xdr {
-                for key in keys {
-                    let key = LedgerKey::ContractData(LedgerKeyContractData {
-                        contract: contract_address_arg.clone(),
-                        key: ScVal::from_xdr_base64(key, Limits::none())?,
-                        durability: ContractDataDurability::Persistent,
-                    });
+        if let Some(wasm_hash) = &self.wasm_hash {
+            for wasm_hash in wasm_hash {
+                let hash = Hash(
+                    soroban_spec_tools::utils::contract_id_from_str(wasm_hash)
+                        .map_err(|_| InvalidHash(wasm_hash.clone()))?,
+                );
+                let key = LedgerKey::ContractCode(LedgerKeyContractCode { hash });
+                ledger_keys.push(key);
+            }
+        }
 
-                    ledger_keys.push(key);
-                }
+        if let Some(config_setting_id) = &self.config_setting_id {
+            for x in config_setting_id {
+                let key = LedgerKey::ConfigSetting(LedgerKeyConfigSetting {
+                    config_setting_id: ConfigSettingId::try_from(*x)
+                        .map_err(|_| InvalidConfigId(*x))?,
+                });
+                ledger_keys.push(key);
+            }
+        }
+
+        if let Some(ttl) = &self.ttl {
+            for x in ttl {
+                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
+                let key = LedgerKey::Ttl(LedgerKeyTtl { key_hash: hash });
+                ledger_keys.push(key);
+            }
+        }
+
+        if ledger_keys.is_empty() {
+            return Err(EmptyKeys);
+        }
+
+        match self.output {
+            OutputFormat::Original => {
+                let resp = client.get_ledger_entries(&ledger_keys).await?;
+                println!("{}", serde_json::to_string(&resp)?);
+            }
+            OutputFormat::Json => {
+                let resp = client.get_full_ledger_entries(&ledger_keys).await?;
+                println!("{}", serde_json::to_string(&resp)?);
+            }
+            OutputFormat::JsonFormatted => {
+                let resp = client.get_full_ledger_entries(&ledger_keys).await?;
+                println!("{}", serde_json::to_string_pretty(&resp)?);
             }
-        } else if self.key.is_some() || self.key_xdr.is_some() {
-            return Err(ContractRequired);
         }
 
+        Ok(())
+    }
+
+    fn insert_accpount_keys(&self, ledger_keys: &mut Vec<LedgerKey>) -> Result<(), Error> {
         if let Some(acc) = &self.account {
             let acc = self.muxed_account(acc)?;
 
             if let Some(asset) = &self.asset {
                 for asset in asset {
-                    let asset = if asset.to_ascii_uppercase() == "XLM" {
+                    let asset = if asset.eq_ignore_ascii_case("XLM") {
                         TrustLineAsset::Native
-                    } else if asset.contains(":") {
-                        let mut parts = asset.split(":");
+                    } else if asset.contains(':') {
+                        let mut parts = asset.split(':');
                         let code = parts.next().ok_or(InvalidAsset(asset.clone()))?;
                         let issuer = parts.next().ok_or(InvalidAsset(asset.clone()))?;
-                        if !parts.next().is_none() {
-                            Err(InvalidAsset(asset.clone()))?
+                        if parts.next().is_some() {
+                            Err(InvalidAsset(asset.clone()))?;
                         }
                         let source_bytes = Ed25519PublicKey::from_string(issuer).unwrap().0;
                         let issuer =
@@ -249,75 +290,47 @@ impl Cmd {
             return Err(AccountRequired);
         }
 
-        if let Some(claimable_id) = &self.claimable_id {
-            for x in claimable_id {
-                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
-                let key = LedgerKey::ClaimableBalance(LedgerKeyClaimableBalance {
-                    balance_id: ClaimableBalanceIdTypeV0(hash),
-                });
-                ledger_keys.push(key);
-            }
-        }
+        Ok(())
+    }
 
-        if let Some(pool_id) = &self.pool_id {
-            for x in pool_id {
-                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
-                let key = LedgerKey::LiquidityPool(LedgerKeyLiquidityPool {
-                    liquidity_pool_id: PoolId(hash),
-                });
-                ledger_keys.push(key);
-            }
-        }
+    fn insert_contract_keys(&self, network: &Network, ledger_keys: &mut Vec<LedgerKey>) -> Result<(), Error> {
+        if let Some(contract_id) = &self.contract_id {
+            let contract_id =
+                contract_id.resolve_contract_id(&self.locator, &network.network_passphrase)?;
 
-        if let Some(wasm_hash) = &self.wasm_hash {
-            for wasm_hash in wasm_hash {
-                let hash = Hash(
-                    soroban_spec_tools::utils::contract_id_from_str(wasm_hash)
-                        .map_err(|_| InvalidHash(wasm_hash.clone()))?,
-                );
-                let key = LedgerKey::ContractCode(LedgerKeyContractCode { hash });
-                ledger_keys.push(key);
-            }
-        }
+            let contract_address_arg = ScAddress::Contract(Hash(contract_id.0));
 
-        if let Some(config_setting_id) = &self.config_setting_id {
-            for x in config_setting_id {
-                let key = LedgerKey::ConfigSetting(LedgerKeyConfigSetting {
-                    config_setting_id: ConfigSettingId::try_from(*x)
-                        .map_err(|_| InvalidConfigId(*x))?,
-                });
-                ledger_keys.push(key);
-            }
-        }
+            if let Some(keys) = &self.key {
+                for key in keys {
+                    let key = LedgerKey::ContractData(LedgerKeyContractData {
+                        contract: contract_address_arg.clone(),
+                        key: soroban_spec_tools::from_string_primitive(
+                            key,
+                            &xdr::ScSpecTypeDef::Symbol,
+                        )?,
+                        durability: ContractDataDurability::Persistent,
+                    });
 
-        if let Some(ttl) = &self.ttl {
-            for x in ttl {
-                let hash = Hash(padded_hex_from_str(x, 32)?.try_into().unwrap());
-                let key = LedgerKey::Ttl(LedgerKeyTtl { key_hash: hash });
-                ledger_keys.push(key);
+                    ledger_keys.push(key);
+                }
             }
-        }
 
-        if ledger_keys.is_empty() {
-            return Err(EmptyKeys);
-        }
+            if let Some(keys) = &self.key_xdr {
+                for key in keys {
+                    let key = LedgerKey::ContractData(LedgerKeyContractData {
+                        contract: contract_address_arg.clone(),
+                        key: ScVal::from_xdr_base64(key, Limits::none())?,
+                        durability: ContractDataDurability::Persistent,
+                    });
 
-        match self.output {
-            OutputFormat::Original => {
-                let resp = client.get_ledger_entries(&ledger_keys).await?;
-                println!("{}", serde_json::to_string(&resp)?);
-            }
-            OutputFormat::Json => {
-                let resp = client.get_full_ledger_entries(&ledger_keys).await?;
-                println!("{}", serde_json::to_string(&resp)?);
-            }
-            OutputFormat::JsonFormatted => {
-                let resp = client.get_full_ledger_entries(&ledger_keys).await?;
-                println!("{}", serde_json::to_string_pretty(&resp)?);
+                    ledger_keys.push(key);
+                }
             }
+        } else if self.key.is_some() || self.key_xdr.is_some() {
+            return Err(ContractRequired);
         }
 
-        return Ok(());
+        Ok(())
     }
 
     fn muxed_account(&self, account: &str) -> Result<MuxedAccount, Error> {