eth: add signing function parameter to specify receive address case

Author: Tomasvrba

Diff for: sandbox/src/Ethereum.tsx

@@ -143,7 +143,8 @@ function EthSignTransaction({ bb02 } : Props) {
         value: new Uint8Array(hexToArrayBuffer(parsed.value)),
         data: new Uint8Array(hexToArrayBuffer(parsed.data)),
       };
-      setResult(await bb02.ethSignTransaction(BigInt(chainID), keypath, tx));
+      const addressCase = await bitbox.ethIdentifyCase(parsed.recipient);
+      setResult(await bb02.ethSignTransaction(BigInt(chainID), keypath, tx, addressCase));
     } catch (err) {
       setErr(bitbox.ensureError(err));
     } finally {
@@ -224,7 +225,8 @@ function EthSignEIP1559Transaction({ bb02 } : Props) {
         value: new Uint8Array(hexToArrayBuffer(parsed.value)),
         data: new Uint8Array(hexToArrayBuffer(parsed.data)),
       };
-      setResult(await bb02.ethSign1559Transaction(keypath, tx));
+      const addressCase = bitbox.ethIdentifyCase(parsed.recipient);
+      setResult(await bb02.ethSign1559Transaction(keypath, tx, addressCase));
     } catch (err) {
       setErr(bitbox.ensureError(err));
     } finally {

Diff for: src/eth.rs

@@ -122,6 +122,19 @@ pub struct EIP1559Transaction {
     pub data: Vec<u8>,
 }
 
+/// Identifies the case of the recipient address given as hexadecimal string.
+/// This function exists as a convenience to potentially help clients to determine the case of the
+/// recipient address.
+pub fn eth_identify_case(recipient_address: &str) -> pb::EthAddressCase {
+    if recipient_address.to_uppercase() == recipient_address {
+        pb::EthAddressCase::Upper
+    } else if recipient_address.to_lowercase() == recipient_address {
+        pb::EthAddressCase::Lower
+    } else {
+        pb::EthAddressCase::Mixed
+    }
+}
+
 #[cfg(feature = "rlp")]
 impl TryFrom<&[u8]> for Transaction {
     type Error = ();
@@ -465,6 +478,7 @@ impl<R: Runtime> PairedBitBox<R> {
         chain_id: u64,
         keypath: &Keypath,
         tx: &Transaction,
+        address_case: Option<pb::EthAddressCase>,
     ) -> Result<[u8; 65], Error> {
         // passing chainID instead of coin only since v9.10.0
         self.validate_version(">=9.10.0")?;
@@ -483,7 +497,7 @@ impl<R: Runtime> PairedBitBox<R> {
                 commitment: crate::antiklepto::host_commit(&host_nonce).to_vec(),
             }),
             chain_id,
-            address_case: pb::EthAddressCase::Mixed as _,
+            address_case: address_case.unwrap_or(pb::EthAddressCase::Mixed).into(),
         });
         let response = self.query_proto_eth(request).await?;
         self.handle_antiklepto(&response, host_nonce).await
@@ -496,6 +510,7 @@ impl<R: Runtime> PairedBitBox<R> {
         &self,
         keypath: &Keypath,
         tx: &EIP1559Transaction,
+        address_case: Option<pb::EthAddressCase>,
     ) -> Result<[u8; 65], Error> {
         // EIP1559 is suported from v9.16.0
         self.validate_version(">=9.16.0")?;
@@ -516,7 +531,7 @@ impl<R: Runtime> PairedBitBox<R> {
             host_nonce_commitment: Some(pb::AntiKleptoHostNonceCommitment {
                 commitment: crate::antiklepto::host_commit(&host_nonce).to_vec(),
             }),
-            address_case: pb::EthAddressCase::Mixed as _,
+            address_case: address_case.unwrap_or(pb::EthAddressCase::Mixed).into(),
         });
         let response = self.query_proto_eth(request).await?;
         self.handle_antiklepto(&response, host_nonce).await

Diff for: src/wasm/mod.rs

@@ -100,6 +100,11 @@ pub fn is_user_abort(err: types::TsError) -> bool {
     }
 }
 
+#[wasm_bindgen(js_name = ethIdentifyCase)]
+pub fn eth_identify_case(recipient_address: &str) -> types::TsEthAddressCase {
+    crate::eth::eth_identify_case(recipient_address).into()
+}
+
 #[wasm_bindgen(raw_module = "./webhid")]
 extern "C" {
     async fn jsSleep(millis: f64);
@@ -410,10 +415,11 @@ impl PairedBitBox {
         chain_id: u64,
         keypath: types::TsKeypath,
         tx: types::TsEthTransaction,
+        address_case: Option<types::TsEthAddressCase>,
     ) -> Result<types::TsEthSignature, JavascriptError> {
         let signature = self
             .device
-            .eth_sign_transaction(chain_id, &keypath.try_into()?, &tx.try_into()?)
+            .eth_sign_transaction(chain_id, &keypath.try_into()?, &tx.try_into()?, address_case.map(TryInto::try_into).transpose()?)
             .await?;
 
         let v: u64 = compute_v(chain_id, signature[64])
@@ -433,10 +439,11 @@ impl PairedBitBox {
         &self,
         keypath: types::TsKeypath,
         tx: types::TsEth1559Transaction,
+        address_case: Option<types::TsEthAddressCase>,
     ) -> Result<types::TsEthSignature, JavascriptError> {
         let signature = self
             .device
-            .eth_sign_1559_transaction(&keypath.try_into()?, &tx.try_into()?)
+            .eth_sign_1559_transaction(&keypath.try_into()?, &tx.try_into()?, address_case.map(TryInto::try_into).transpose()?)
             .await?;
 
         Ok(serde_wasm_bindgen::to_value(&types::EthSignature {

Diff for: src/wasm/types.rs

@@ -75,6 +75,7 @@ type EthSignature = {
   s: Uint8Array;
   v: Uint8Array;
 };
+type EthAddressCase = 'Upper' | 'Lower' | 'Mixed';
 type CardanoXpub = Uint8Array;
 type CardanoXpubs = CardanoXpub[];
 type CardanoNetwork = 'mainnet' | 'testnet';
@@ -186,6 +187,8 @@ extern "C" {
     pub type TsEth1559Transaction;
     #[wasm_bindgen(typescript_type = "EthSignature")]
     pub type TsEthSignature;
+    #[wasm_bindgen(typescript_type = "EthAddressCase")]
+    pub type TsEthAddressCase;
     #[wasm_bindgen(typescript_type = "CardanoXpub")]
     pub type TsCardanoXpub;
     #[wasm_bindgen(typescript_type = "CardanoXpubs")]
@@ -283,6 +286,20 @@ impl TryFrom<TsEth1559Transaction> for crate::eth::EIP1559Transaction {
     }
 }
 
+impl TryFrom<TsEthAddressCase> for crate::pb::EthAddressCase {
+  type Error = JavascriptError;
+  fn try_from(value: TsEthAddressCase) -> Result<Self, Self::Error> {
+      serde_wasm_bindgen::from_value(value.into())
+          .map_err(|_| JavascriptError::InvalidType("wrong type for EthAddressCase"))
+  }
+}
+
+impl From<crate::pb::EthAddressCase> for TsEthAddressCase {
+  fn from(case: crate::pb::EthAddressCase) -> Self {
+      serde_wasm_bindgen::to_value(&case).unwrap().into()
+  }
+}
+
 impl TryFrom<TsCardanoNetwork> for crate::pb::CardanoNetwork {
     type Error = JavascriptError;
     fn try_from(value: TsCardanoNetwork) -> Result<Self, Self::Error> {