Add remaining types

Author: Gleb

cmd/soroban-cli/src/commands/contract/read.rs

@@ -144,18 +144,19 @@ impl Cmd {
                             error,
                         }
                     })?,
-                    serde_json::to_string_pretty(&live_until_ledger_seq.unwrap_or_default()).map_err(|error| {
-                        Error::CannotPrintJsonResult {
+                    serde_json::to_string_pretty(&live_until_ledger_seq.unwrap_or_default())
+                        .map_err(|error| Error::CannotPrintJsonResult {
                             result: val.clone(),
                             error,
-                        }
-                    })?,
+                        })?,
                 ],
                 Output::Xdr => [
                     key.to_xdr_base64(Limits::none())?,
                     val.to_xdr_base64(Limits::none())?,
                     last_modified_ledger.to_xdr_base64(Limits::none())?,
-                    live_until_ledger_seq.unwrap_or_default().to_xdr_base64(Limits::none())?,
+                    live_until_ledger_seq
+                        .unwrap_or_default()
+                        .to_xdr_base64(Limits::none())?,
                 ],
             };
             out.write_record(output)

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

@@ -1,41 +1,79 @@
+use std::array::TryFromSliceError;
 use std::fmt::Debug;
 
-use clap::{command, Parser};
-use stellar_xdr::curr::{ContractDataDurability, Hash, LedgerKey, LedgerKeyAccount, LedgerKeyContractData, Limits, MuxedAccount, ReadXdr, ScAddress, ScVal};
 use crate::commands::config::network;
+use crate::commands::contract::Durability;
+use crate::commands::ledger::entry::get::Error::{
+    AccountRequired, ContractRequired, EmptyKeys, InvalidAsset, InvalidConfigId, InvalidDataName,
+    InvalidHash,
+};
+use crate::config::locator;
+use crate::rpc::{self};
 use crate::{config, xdr};
-use crate::config::{locator};
-use crate::{
-    rpc::{self},
+use clap::{command, Parser};
+use hex::FromHexError;
+use soroban_spec_tools::utils::padded_hex_from_str;
+use stellar_strkey::ed25519::PublicKey as Ed25519PublicKey;
+use stellar_xdr::curr::ClaimableBalanceId::ClaimableBalanceIdTypeV0;
+use stellar_xdr::curr::{
+    AccountId, AlphaNum12, AlphaNum4, AssetCode12, AssetCode4, ConfigSettingId,
+    ContractDataDurability, Hash, LedgerKey, LedgerKeyAccount, LedgerKeyClaimableBalance,
+    LedgerKeyConfigSetting, LedgerKeyContractCode, LedgerKeyContractData, LedgerKeyData,
+    LedgerKeyLiquidityPool, LedgerKeyOffer, LedgerKeyTrustLine, LedgerKeyTtl, Limits, MuxedAccount,
+    PoolId, PublicKey, ReadXdr, ScAddress, ScVal, String64, TrustLineAsset, Uint256,
 };
-use crate::commands::contract::Durability;
-use crate::commands::ledger::entry::get::Error::{ContractRequired, EmptyKeys};
 
 #[derive(Parser, Debug, Clone)]
 #[group(skip)]
 pub struct Cmd {
     #[command(flatten)]
     pub network: network::Args,
-
     #[command(flatten)]
     pub locator: locator::Args,
 
     /// Name of identity to lookup, default is test identity
     #[arg(long)]
     pub account: Option<String>,
-
     /// If identity is a seed phrase use this hd path, default is 0
     #[arg(long)]
     pub hd_path: Option<usize>,
 
+    /// Assets to get trustline info for
+    #[arg(long)]
+    pub asset: Option<Vec<String>>,
+    /// ID of an offer made on the Stellar DEX
+    #[arg(long)]
+    pub offer: Option<Vec<i64>>,
+    /// Fetch key-value data entries attached to an account (see manageDataOp)
+    #[arg(long)]
+    pub data_name: Option<Vec<String>>,
+
+    /// Claimable Balance id
+    #[arg(long)]
+    pub claimable_id: Option<Vec<String>>,
 
+    /// Liquidity pool id
+    #[arg(long)]
+    pub pool_id: Option<Vec<String>>,
+
+    /// Defines the currently active network configuration
+    #[arg(long)]
+    pub config_setting_id: Option<Vec<i32>>,
+
+    /// Get WASM bytecode by hash
+    #[arg(long)]
+    pub wasm_hash: Option<Vec<String>>,
+
+    /// Get the time-to-live of an associated contract data or code entry
+    #[arg(long)]
+    pub ttl: Option<Vec<String>>,
+
+    /// Contract id to fetch an info for
     #[arg(long = "id", env = "STELLAR_CONTRACT_ID")]
     pub contract_id: Option<config::UnresolvedContract>,
-
     /// Storage entry durability
     #[arg(long, value_enum, default_value = "persistent")]
     pub durability: Durability,
-
     /// Storage key (symbols only)
     #[arg(long = "key")]
     pub key: Option<Vec<String>>,
@@ -64,10 +102,24 @@ pub enum Error {
     StellarXdr(#[from] stellar_xdr::curr::Error),
     #[error(transparent)]
     Spec(#[from] soroban_spec_tools::Error),
+    #[error(transparent)]
+    TryFromSliceError(#[from] TryFromSliceError),
+    #[error(transparent)]
+    FromHexError(#[from] FromHexError),
     #[error("at least one key must be provided")]
     EmptyKeys,
     #[error("contract id is required but was not provided")]
     ContractRequired,
+    #[error("account is required but was not provided")]
+    AccountRequired,
+    #[error("provided asset is invalid: {0}")]
+    InvalidAsset(String),
+    #[error("provided data name is invalid: {0}")]
+    InvalidDataName(String),
+    #[error("provided hash value is invalid: {0}")]
+    InvalidHash(String),
+    #[error("provided config id is invalid: {0}")]
+    InvalidConfigId(i32),
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, clap::ValueEnum, Default)]
@@ -81,15 +133,15 @@ pub enum OutputFormat {
     JsonFormatted,
 }
 
-
 impl Cmd {
     pub async fn run(&self) -> Result<(), Error> {
         let network = self.network.get(&self.locator)?;
         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)?;
+            let contract_id =
+                contract_id.resolve_contract_id(&self.locator, &network.network_passphrase)?;
 
             let contract_address_arg = ScAddress::Contract(Hash(contract_id.0));
 
@@ -120,15 +172,131 @@ impl Cmd {
                 }
             }
         } else if self.key.is_some() || self.key_xdr.is_some() {
-            return Err(ContractRequired)
+            return Err(ContractRequired);
         }
 
         if let Some(acc) = &self.account {
             let acc = self.muxed_account(acc)?;
-            let key = LedgerKey::Account(LedgerKeyAccount { account_id: acc.account_id() });
-            ledger_keys.push(key);
+
+            if let Some(asset) = &self.asset {
+                for asset in asset {
+                    let asset = if asset.to_ascii_uppercase() == "XLM" {
+                        TrustLineAsset::Native
+                    } 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()))?
+                        }
+                        let source_bytes = Ed25519PublicKey::from_string(issuer).unwrap().0;
+                        let issuer =
+                            AccountId(PublicKey::PublicKeyTypeEd25519(Uint256(source_bytes)));
+
+                        match code.len() {
+                            4 => TrustLineAsset::CreditAlphanum4(AlphaNum4 {
+                                asset_code: AssetCode4(code.as_bytes().try_into()?),
+                                issuer,
+                            }),
+                            12 => TrustLineAsset::CreditAlphanum12(AlphaNum12 {
+                                asset_code: AssetCode12(code.as_bytes().try_into()?),
+                                issuer,
+                            }),
+                            _ => Err(InvalidAsset(asset.clone()))?,
+                        }
+                    } else {
+                        Err(InvalidAsset(asset.clone()))?
+                    };
+                    let key = LedgerKey::Trustline(LedgerKeyTrustLine {
+                        account_id: acc.clone().account_id(),
+                        asset,
+                    });
+                    ledger_keys.push(key);
+                }
+            }
+
+            if let Some(offer) = &self.offer {
+                for offer in offer {
+                    let key = LedgerKey::Offer(LedgerKeyOffer {
+                        seller_id: acc.clone().account_id(),
+                        offer_id: *offer,
+                    });
+                    ledger_keys.push(key);
+                }
+            }
+
+            if let Some(data_name) = &self.data_name {
+                for data_name in data_name {
+                    let data_name: xdr::StringM<64> = data_name
+                        .parse()
+                        .map_err(|_| InvalidDataName(data_name.clone()))?;
+                    let data_name = String64(data_name);
+                    let key = LedgerKey::Data(LedgerKeyData {
+                        account_id: acc.clone().account_id(),
+                        data_name,
+                    });
+                    ledger_keys.push(key);
+                }
+            }
+
+            if self.asset.is_none() && self.offer.is_none() && self.data_name.is_none() {
+                let key = LedgerKey::Account(LedgerKeyAccount {
+                    account_id: acc.account_id(),
+                });
+                ledger_keys.push(key);
+            }
+        } else if self.asset.is_some() || self.offer.is_some() || self.data_name.is_some() {
+            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);
+            }
+        }
+
+        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(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);
+            }
+        }
+
+        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);
@@ -149,7 +317,6 @@ impl Cmd {
             }
         }
 
-
         return Ok(());
     }
 

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

@@ -3,7 +3,8 @@ use clap::Parser;
 
 #[derive(Debug, Parser)]
 pub enum Cmd {
-    /// Get ledger entries.
+    /// 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
     Get(get::Cmd),
 }
 
@@ -20,4 +21,4 @@ impl Cmd {
         };
         Ok(())
     }
-}
+}

cmd/soroban-cli/src/commands/ledger/mod.rs

@@ -22,4 +22,4 @@ impl Cmd {
         };
         Ok(())
     }
-}
+}

cmd/soroban-cli/src/commands/mod.rs

@@ -19,8 +19,8 @@ pub mod snapshot;
 pub mod tx;
 pub mod version;
 
-pub mod txn_result;
 pub mod ledger;
+pub mod txn_result;
 
 pub const HEADING_RPC: &str = "Options (RPC)";
 pub const HEADING_GLOBAL: &str = "Options (Global)";