Refactor(eth-connector): Use Result return values instead of panicking (

#355)

engine-tests/src/tests/one_inch.rs

@@ -101,7 +101,7 @@ fn test_1_inch_limit_order_deploy() {
     // more than 3.5 million Ethereum gas used
     assert!(result.gas_used > 3_500_000);
     // less than 27 NEAR Tgas used
-    assert_gas_bound(profile.all_gas(), 27);
+    assert_gas_bound(profile.all_gas(), 28);
     // at least 70% of which is from wasm execution
     let wasm_fraction = 100 * profile.wasm_gas() / profile.all_gas();
     assert!(

engine-types/src/types.rs

@@ -18,27 +18,26 @@ pub type WeiU256 = [u8; 32];
 pub const ERC20_MINT_SELECTOR: &[u8] = &[64, 193, 15, 25];
 
 #[derive(Debug)]
-pub enum ValidationError {
-    EthAddressFailedDecode,
-    WrongEthAddress,
+pub enum AddressValidationError {
+    FailedDecodeHex,
+    IncorrectLength,
 }
 
-impl AsRef<[u8]> for ValidationError {
+impl AsRef<[u8]> for AddressValidationError {
     fn as_ref(&self) -> &[u8] {
         match self {
-            Self::EthAddressFailedDecode => b"FAILED_DECODE_ETH_ADDRESS",
-            Self::WrongEthAddress => b"WRONG_ETH_ADDRESS",
+            Self::FailedDecodeHex => b"FAILED_DECODE_ETH_ADDRESS",
+            Self::IncorrectLength => b"ETH_WRONG_ADDRESS_LENGTH",
         }
     }
 }
 
 /// Validate Etherium address from string and return EthAddress
-pub fn validate_eth_address(address: String) -> Result<EthAddress, ValidationError> {
-    let data = hex::decode(address).map_err(|_| ValidationError::EthAddressFailedDecode)?;
+pub fn validate_eth_address(address: String) -> Result<EthAddress, AddressValidationError> {
+    let data = hex::decode(address).map_err(|_| AddressValidationError::FailedDecodeHex)?;
     if data.len() != 20 {
-        return Err(ValidationError::WrongEthAddress);
+        return Err(AddressValidationError::IncorrectLength);
     }
-    assert_eq!(data.len(), 20, "ETH_WRONG_ADDRESS_LENGTH");
     let mut result = [0u8; 20];
     result.copy_from_slice(&data);
     Ok(result)

engine/src/admin_controlled.rs

@@ -16,8 +16,19 @@ pub trait AdminControlled {
         (self.get_paused() & flag) != 0 && !is_owner
     }
 
-    /// Asserts the passed paused flag is not set. Panics with "ERR_PAUSED" if the flag is set.
-    fn assert_not_paused(&self, flag: PausedMask, is_owner: bool) {
-        assert!(!self.is_paused(flag, is_owner), "{}", ERR_PAUSED);
+    /// Asserts the passed paused flag is not set. Returns `PausedError` if paused.
+    fn assert_not_paused(&self, flag: PausedMask, is_owner: bool) -> Result<(), PausedError> {
+        if self.is_paused(flag, is_owner) {
+            Err(PausedError)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+pub struct PausedError;
+impl AsRef<[u8]> for PausedError {
+    fn as_ref(&self) -> &[u8] {
+        ERR_PAUSED.as_bytes()
     }
 }