Merge branch 'main' into sr/better-error

Author: mehcode

README.md

@@ -12,13 +12,13 @@
 ## Requirements
 
 - [Rust](https://rustup.rs)
-- [Swift](https://www.swift.org/getting-started/)
-- [Task](https://taskfile.dev)
+- [protoc](https://grpc.io/docs/protoc-installation)
 
 Execute command in root directory:
 ```bash
-task build
+cargo check
 ```
+
 ## API Docs
 
 Check out the Hedera Rust SDK API reference docs [here](http://docs.rs/hedera/latest/hedera/index.html).

Taskfile.yml

@@ -271,6 +271,7 @@ impl From<EntityId> for AccountId {
 mod tests {
     use std::str::FromStr;
 
+    use assert_matches::assert_matches;
     use hex_literal::hex;
 
     use crate::ethereum::EvmAddress;
@@ -375,4 +376,137 @@ mod tests {
             "0.0.123-esxsf"
         );
     }
+
+    #[tokio::test]
+    async fn bad_checksum_on_previewnet() {
+        let client = Client::for_previewnet();
+        let id = AccountId::from_str("0.0.123-ntjli").unwrap();
+
+        assert_matches!(
+            id.validate_checksum(&client),
+            Err(crate::Error::BadEntityId {
+                shard: 0,
+                realm: 0,
+                num: 123,
+                present_checksum: _,
+                expected_checksum: _
+            })
+        );
+    }
+
+    #[test]
+    fn malformed_id_fails() {
+        assert_matches!(AccountId::from_str("0.0."), Err(crate::Error::BasicParse(_)));
+    }
+
+    #[test]
+    fn malformed_checksum() {
+        assert_matches!(AccountId::from_str("0.0.123-ntjl"), Err(crate::Error::BasicParse(_)));
+    }
+
+    #[test]
+    fn malformed_checksum_2() {
+        assert_matches!(AccountId::from_str("0.0.123-ntjl1"), Err(crate::Error::BasicParse(_)));
+    }
+
+    #[test]
+    fn malformed_alias() {
+        assert_matches!(AccountId::from_str("0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf777"), Err(crate::Error::KeyParse(_)));
+    }
+    #[test]
+    fn malformed_alias_2() {
+        assert_matches!(AccountId::from_str("0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf777g"), Err(crate::Error::KeyParse(_)));
+    }
+    #[test]
+    fn malformed_alias_key_3() {
+        assert_matches!(AccountId::from_str("0.0.303a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf7777"), Err(crate::Error::KeyParse(_)));
+    }
+
+    #[test]
+    fn from_string_alias_key() {
+        expect_test::expect!["0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf7777"]
+        .assert_eq(&AccountId::from_str("0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf7777").unwrap().to_string())
+    }
+
+    #[test]
+    fn from_string_evm_address() {
+        expect_test::expect!["0x302a300506032b6570032100114e6abc371b82da"].assert_eq(
+            &AccountId::from_str("0x302a300506032b6570032100114e6abc371b82da").unwrap().to_string(),
+        );
+    }
+
+    #[test]
+    fn from_solidity_address() {
+        expect_test::expect!["0.0.5005"].assert_eq(
+            &AccountId::from_solidity_address("000000000000000000000000000000000000138D")
+                .unwrap()
+                .to_string(),
+        );
+    }
+
+    #[test]
+    fn from_solidity_address_0x() {
+        expect_test::expect!["0.0.5005"].assert_eq(
+            &AccountId::from_solidity_address("0x000000000000000000000000000000000000138D")
+                .unwrap()
+                .to_string(),
+        );
+    }
+
+    #[test]
+    fn from_bytes() {
+        let bytes = AccountId {
+            shard: 0,
+            realm: 0,
+            num: 5005,
+            alias: None,
+            evm_address: None,
+            checksum: None,
+        }
+        .to_bytes();
+
+        expect_test::expect!["0.0.5005"]
+            .assert_eq(&AccountId::from_bytes(&bytes).unwrap().to_string());
+    }
+
+    #[test]
+    fn from_bytes_alias() {
+        let bytes = AccountId::from_str("0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf7777").unwrap().to_bytes();
+
+        expect_test::expect!["0.0.302a300506032b6570032100114e6abc371b82dab5c15ea149f02d34a012087b163516dd70f44acafabf7777"].assert_eq(&AccountId::from_bytes(&bytes).unwrap().to_string());
+    }
+
+    #[test]
+    fn from_bytes_evm_address() {
+        let bytes =
+            AccountId::from_str("0x302a300506032b6570032100114e6abc371b82da").unwrap().to_bytes();
+        expect_test::expect!["0.0.0"]
+            .assert_eq(&AccountId::from_bytes(&bytes).unwrap().to_string());
+    }
+
+    #[test]
+    fn to_solidity_address() {
+        let id = AccountId {
+            shard: 0,
+            realm: 0,
+            num: 5005,
+            alias: None,
+            evm_address: None,
+            checksum: None,
+        };
+
+        expect_test::expect!["000000000000000000000000000000000000138d"]
+            .assert_eq(&id.to_solidity_address().unwrap());
+    }
+
+    #[test]
+    fn from_evm_address() {
+        let evm_address =
+            EvmAddress::from_str("0x302a300506032b6570032100114e6abc371b82da").unwrap();
+
+        let id = AccountId::from_evm_address(&evm_address);
+
+        expect_test::expect!["0x302a300506032b6570032100114e6abc371b82da"]
+            .assert_eq(&id.to_string());
+    }
 }

src/account/account_id.rs

@@ -269,3 +269,89 @@ impl From<EntityId> for ContractId {
         Self { shard, realm, num, evm_address: None, checksum }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use crate::ContractId;
+
+    #[test]
+    fn parse() {
+        expect_test::expect!["0.0.5005"]
+            .assert_eq(&ContractId::from_str("0.0.5005").unwrap().to_string());
+    }
+
+    #[test]
+    fn from_solidity_address() {
+        expect_test::expect!["0.0.5005"].assert_eq(
+            &ContractId::from_solidity_address("000000000000000000000000000000000000138D")
+                .unwrap()
+                .to_string(),
+        );
+    }
+
+    #[test]
+    fn from_solidity_address_0x() {
+        expect_test::expect!["0.0.5005"].assert_eq(
+            &ContractId::from_solidity_address("0x000000000000000000000000000000000000138D")
+                .unwrap()
+                .to_string(),
+        );
+    }
+
+    #[test]
+    fn from_evm_address() {
+        expect_test::expect!["1.2.98329e006610472e6b372c080833f6d79ed833cf"].assert_eq(
+            &ContractId::from_evm_address(1, 2, "98329e006610472e6B372C080833f6D79ED833cf")
+                .unwrap()
+                .to_string(),
+        )
+    }
+
+    #[test]
+    fn from_evm_address_0x() {
+        expect_test::expect!["1.2.98329e006610472e6b372c080833f6d79ed833cf"].assert_eq(
+            &ContractId::from_evm_address(1, 2, "0x98329e006610472e6B372C080833f6D79ED833cf")
+                .unwrap()
+                .to_string(),
+        )
+    }
+
+    #[test]
+    fn parse_evm_address() {
+        expect_test::expect!["1.2.98329e006610472e6b372c080833f6d79ed833cf"].assert_eq(
+            &ContractId::from_str("1.2.0x98329e006610472e6B372C080833f6D79ED833cf")
+                .unwrap()
+                .to_string(),
+        )
+    }
+
+    #[test]
+    fn to_from_bytes() {
+        let a = ContractId::from_str("1.2.3").unwrap();
+        assert_eq!(ContractId::from_bytes(&a.to_bytes()).unwrap(), a);
+        let b = ContractId::from_evm_address(1, 2, "0x98329e006610472e6B372C080833f6D79ED833cf")
+            .unwrap();
+        assert_eq!(ContractId::from_bytes(&b.to_bytes()).unwrap(), b);
+    }
+
+    #[test]
+    fn to_solidity_address() {
+        expect_test::expect!["000000000000000000000000000000000000138d"].assert_eq(
+            &ContractId { shard: 0, realm: 0, num: 5005, checksum: None, evm_address: None }
+                .to_solidity_address()
+                .unwrap(),
+        )
+    }
+
+    #[test]
+    fn to_solidity_address_2() {
+        expect_test::expect!["98329e006610472e6b372c080833f6d79ed833cf"].assert_eq(
+            &ContractId::from_evm_address(1, 2, "0x98329e006610472e6B372C080833f6D79ED833cf")
+                .unwrap()
+                .to_solidity_address()
+                .unwrap(),
+        )
+    }
+}

src/contract/contract_id.rs

@@ -48,9 +48,15 @@ impl FromStr for Checksum {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        s.parse()
-            .map(Checksum)
-            .map_err(|_| Error::basic_parse("Expected checksum to be exactly 5 characters"))
+        let ascii_str: TinyAsciiStr<5> = s
+            .parse()
+            .map_err(|e| Error::basic_parse(format!("Expected checksum to be valid ascii: {e}")))?;
+
+        if ascii_str.len() != 5 || !ascii_str.is_ascii_alphabetic_lowercase() {
+            return Err(Error::basic_parse("Expected checksum to be exactly 5 lowercase letters"));
+        }
+
+        Ok(Self(ascii_str))
     }
 }
 
@@ -130,6 +136,10 @@ impl<'a> PartialEntityId<'a> {
             Some((shard, rest)) => {
                 let (realm, last) = rest.split_once('.').ok_or_else(expecting)?;
 
+                if last.is_empty() {
+                    return Err(expecting());
+                }
+
                 let shard = shard.parse().map_err(|_| expecting())?;
                 let realm = realm.parse().map_err(|_| expecting())?;
 

src/entity_id.rs

@@ -63,14 +63,22 @@ pub struct CustomFee<Fee> {
     /// The account to receive the custom fee.
     pub fee_collector_account_id: Option<AccountId>,
 
+    /// If true, fee fcollectors are not charged this fee for transfers.
     pub all_collectors_are_exempt: bool,
 }
 
 impl AnyCustomFee {
+    /// Create `AnyCustomFee` from protobuf-encoded `bytes`.
+    ///
+    /// # Errors
+    /// - [`Error::FromProtobuf`](crate::Error::FromProtobuf) if decoding the bytes fails to produce a valid protobuf.
+    /// - [`Error::FromProtobuf`](crate::Error::FromProtobuf) if decoding the protobuf fails.
     pub fn from_bytes(bytes: &[u8]) -> crate::Result<Self> {
         FromProtobuf::from_bytes(bytes)
     }
 
+    /// Convert `self` to a protobuf-encoded [`Vec<u8>`].
+    #[must_use]
     pub fn to_bytes(&self) -> Vec<u8> {
         ToProtobuf::to_bytes(self)
     }
@@ -206,30 +214,26 @@ pub struct FixedFeeData {
 
     /// The denomination of the fee; taken as hbar if left unset and, in a TokenCreate, taken as the id
     /// of the newly created token if set to the sentinel value of 0.0.0
-    pub denominating_token_id: TokenId,
+    pub denominating_token_id: Option<TokenId>,
 }
 
 impl FixedFeeData {
     #[must_use]
     pub fn from_hbar(amount: Hbar) -> Self {
-        Self {
-            amount: amount.to_tinybars(),
-            denominating_token_id: TokenId { shard: 0, realm: 0, num: 0, checksum: None },
-        }
+        Self { amount: amount.to_tinybars(), denominating_token_id: None }
     }
 
     #[must_use]
     pub fn get_hbar(&self) -> Option<Hbar> {
-        (self.denominating_token_id == TokenId { shard: 0, realm: 0, num: 0, checksum: None })
-            .then(|| Hbar::from_tinybars(self.amount))
+        self.denominating_token_id.is_none().then(|| Hbar::from_tinybars(self.amount))
     }
 }
 
 impl FromProtobuf<services::FixedFee> for FixedFeeData {
     fn from_protobuf(pb: services::FixedFee) -> crate::Result<Self> {
         Ok(Self {
             amount: pb.amount,
-            denominating_token_id: TokenId::from_protobuf(pb_getf!(pb, denominating_token_id)?)?,
+            denominating_token_id: Option::from_protobuf(pb.denominating_token_id)?,
         })
     }
 }
@@ -240,7 +244,7 @@ impl ToProtobuf for FixedFeeData {
     fn to_protobuf(&self) -> Self::Protobuf {
         Self::Protobuf {
             amount: self.amount,
-            denominating_token_id: Some(self.denominating_token_id.to_protobuf()),
+            denominating_token_id: self.denominating_token_id.to_protobuf(),
         }
     }
 }