Merge pull request #489 from hashgraph/sr/flows

Author: mehcode

sdk/rust/Cargo.lock

@@ -47,6 +47,8 @@ tokio = { version = "1.24.2", features = ["rt-multi-thread"] }
 tonic = "0.8.0"
 tinystr = "0.7.0"
 arc-swap = "1.6.0"
+rlp = "0.5.2"
+bytes = "1.2.1"
 
 [dependencies.rust_decimal]
 version = "1.26.1"

sdk/rust/Cargo.toml

@@ -164,7 +164,7 @@ impl PrivateKey {
     }
 
     pub(crate) fn from_encrypted_info(der: &[u8], password: &[u8]) -> crate::Result<Self> {
-        let info = pkcs8::EncryptedPrivateKeyInfo::from_der(&der)
+        let info = pkcs8::EncryptedPrivateKeyInfo::from_der(der)
             .map_err(|e| Error::key_parse(e.to_string()))?;
 
         let decrypted = info.decrypt(password).map_err(|e| Error::key_parse(e.to_string()))?;

sdk/rust/crypto/src/key/private.rs

@@ -33,11 +33,11 @@ use crate::entity_id::{
     PartialEntityId,
     ValidateChecksums,
 };
-use crate::evm_address::EvmAddress;
 use crate::{
     Client,
     EntityId,
     Error,
+    EvmAddress,
     FromProtobuf,
     LedgerId,
     PublicKey,
@@ -274,7 +274,7 @@ mod tests {
 
     use hex_literal::hex;
 
-    use crate::evm_address::EvmAddress;
+    use crate::ethereum::EvmAddress;
     use crate::{
         AccountId,
         Client,

sdk/rust/src/account/account_id.rs

@@ -0,0 +1,64 @@
+/*
+ * ‌
+ * Hedera Rust SDK
+ * ​
+ * Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
+ * ​
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ‍
+ */
+
+use crate::transaction::TransactionExecute;
+use crate::{
+    AccountId,
+    AccountInfoQuery,
+    Client,
+    Error,
+    Key,
+    PublicKey,
+    Transaction,
+};
+
+async fn query_pk(client: &Client, account_id: AccountId) -> crate::Result<PublicKey> {
+    let key = AccountInfoQuery::new().account_id(account_id).execute(client).await?.key;
+
+    match key {
+        Key::Single(it) => Ok(it),
+        _ => {
+            Err(Error::signature_verify("`{account_id}`: unsupported key kind: {key:?}".to_owned()))
+        }
+    }
+}
+
+/// Verify the `signature` for `msg` via the given account's public key.
+pub async fn verify_signature(
+    client: &Client,
+    account_id: AccountId,
+    msg: impl AsRef<[u8]>,
+    signature: impl AsRef<[u8]>,
+) -> crate::Result<()> {
+    let key = query_pk(client, account_id).await?;
+
+    key.verify(msg.as_ref(), signature.as_ref())
+}
+
+/// Returns `Ok(())` if the given account's public key has signed the given transaction.
+pub async fn verify_transaction_signature<D: TransactionExecute>(
+    client: &Client,
+    account_id: AccountId,
+    transaction: &mut Transaction<D>,
+) -> crate::Result<()> {
+    let key = query_pk(client, account_id).await?;
+
+    key.verify_transaction(transaction)
+}

sdk/rust/src/account/account_info_flow.rs

@@ -26,6 +26,9 @@ mod account_create_transaction;
 mod account_delete_transaction;
 mod account_id;
 mod account_info;
+// note(sr): there's absolutely no way I'm going to write an enum or struct for namespacing here.
+/// Flow for verifying signatures via account info.
+pub mod account_info_flow;
 mod account_info_query;
 mod account_records_query;
 mod account_stakers_query;

sdk/rust/src/account/mod.rs

@@ -18,6 +18,7 @@
  * ‍
  */
 
+use std::fmt;
 use std::sync::atomic::{
     AtomicBool,
     AtomicU64,
@@ -58,6 +59,13 @@ struct ClientInner {
 #[derive(Clone)]
 pub struct Client(Arc<ClientInner>);
 
+impl fmt::Debug for Client {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // todo: put anything important here.
+        f.debug_tuple("Client").finish()
+    }
+}
+
 impl Client {
     fn with_network(
         network: Network,