feat(core): add helpers to unwrap TypedTransaction

ethers-core/src/types/transaction/eip2718.rs

@@ -60,6 +60,9 @@ pub enum TypedTransactionError {
     /// Missing transaction payload when decoding from RLP
     #[error("Missing transaction payload when decoding")]
     MissingTransactionPayload,
+    /// Wrong transaction type requested
+    #[error("Wrong transaction type requested")]
+    WrongTransactionType,
 }
 
 #[cfg(feature = "legacy")]
@@ -398,6 +401,143 @@ impl From<&Transaction> for TypedTransaction {
     }
 }
 
+impl TypedTransaction {
+    #[allow(dead_code)]
+    fn as_legacy_ref(&self) -> Result<&TransactionRequest, TypedTransactionError> {
+        match self {
+            Legacy(tx) => Ok(tx),
+            _ => Err(TypedTransactionError::WrongTransactionType),
+        }
+    }
+    #[allow(dead_code)]
+    fn as_eip2930_ref(&self) -> Result<&Eip2930TransactionRequest, TypedTransactionError> {
+        match self {
+            Eip2930(tx) => Ok(tx),
+            _ => Err(TypedTransactionError::WrongTransactionType),
+        }
+    }
+    #[allow(dead_code)]
+    fn as_eip1559_ref(&self) -> Result<&Eip1559TransactionRequest, TypedTransactionError> {
+        match self {
+            Eip1559(tx) => Ok(tx),
+            _ => Err(TypedTransactionError::WrongTransactionType),
+        }
+    }
+}
+
+impl TypedTransaction {
+    fn as_eip1559(&self) -> Eip1559TransactionRequest {
+        match self {
+            Eip1559(tx) => tx.clone(),
+            _ => Eip1559TransactionRequest {
+                from: self.from().copied(),
+                to: self.to().cloned(),
+                nonce: self.nonce().copied(),
+                value: self.value().copied(),
+                gas: self.gas().copied(),
+                chain_id: self.chain_id(),
+                data: self.data().cloned(),
+                access_list: self.access_list().cloned().unwrap_or_default(),
+                ..Default::default()
+            },
+        }
+    }
+    fn into_eip1559(self) -> Eip1559TransactionRequest {
+        match self {
+            Eip1559(tx) => tx,
+            _ => (&self).as_eip1559(),
+        }
+    }
+}
+
+impl From<&TypedTransaction> for Eip1559TransactionRequest {
+    fn from(src: &TypedTransaction) -> Eip1559TransactionRequest {
+        src.as_eip1559()
+    }
+}
+
+impl From<TypedTransaction> for Eip1559TransactionRequest {
+    fn from(src: TypedTransaction) -> Eip1559TransactionRequest {
+        src.into_eip1559()
+    }
+}
+
+impl TypedTransaction {
+    fn as_legacy(&self) -> TransactionRequest {
+        match self {
+            Legacy(tx) => tx.clone(),
+            _ => TransactionRequest {
+                from: self.from().copied(),
+                to: self.to().cloned(),
+                nonce: self.nonce().copied(),
+                value: self.value().copied(),
+                gas: self.gas().copied(),
+                gas_price: self.gas_price(),
+                chain_id: self.chain_id(),
+                data: self.data().cloned(),
+                #[cfg(feature = "celo")]
+                #[cfg_attr(docsrs, doc(cfg(feature = "celo")))]
+                fee_currency: None,
+                #[cfg(feature = "celo")]
+                #[cfg_attr(docsrs, doc(cfg(feature = "celo")))]
+                gateway_fee_recipient: None,
+                #[cfg(feature = "celo")]
+                #[cfg_attr(docsrs, doc(cfg(feature = "celo")))]
+                gateway_fee: None,
+            },
+        }
+    }
+    fn into_legacy(self) -> TransactionRequest {
+        match self {
+            Legacy(tx) => tx,
+            _ => (&self).as_legacy(),
+        }
+    }
+}
+
+impl From<&TypedTransaction> for TransactionRequest {
+    fn from(src: &TypedTransaction) -> TransactionRequest {
+        src.as_legacy()
+    }
+}
+
+impl From<TypedTransaction> for TransactionRequest {
+    fn from(src: TypedTransaction) -> TransactionRequest {
+        src.into_legacy()
+    }
+}
+
+impl TypedTransaction {
+    fn as_eip2930(&self) -> Eip2930TransactionRequest {
+        match self {
+            Eip2930(tx) => tx.clone(),
+            _ => Eip2930TransactionRequest {
+                tx: self.as_legacy(),
+                access_list: self.access_list().cloned().unwrap_or_default(),
+            },
+        }
+    }
+
+    fn into_eip2930(self) -> Eip2930TransactionRequest {
+        match self {
+            Eip2930(tx) => tx,
+            _ => (&self).as_eip2930(),
+        }
+    }
+}
+
+impl From<&TypedTransaction> for Eip2930TransactionRequest {
+    fn from(src: &TypedTransaction) -> Eip2930TransactionRequest {
+        src.as_eip2930()
+    }
+}
+
+impl From<TypedTransaction> for Eip2930TransactionRequest {
+    fn from(src: TypedTransaction) -> Eip2930TransactionRequest {
+        src.into_eip2930()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use hex::ToHex;
@@ -614,4 +754,47 @@ mod tests {
         let addr = Address::from_str("0x216b32eCEbAe6aF164921D3943cd7A9634FcB199").unwrap();
         assert_eq!(addr, tx.from.unwrap());
     }
+
+    #[test]
+    fn test_tx_casts() {
+        // eip1559 tx
+        let typed_tx_hex = hex::decode("02f86b8205390284773594008477359400830186a09496216849c49358b10257cb55b28ea603c874b05e865af3107a4000825544f838f7940000000000000000000000000000000000000001e1a00100000000000000000000000000000000000000000000000000000000000000").unwrap();
+        let tx_rlp = rlp::Rlp::new(typed_tx_hex.as_slice());
+        let tx = TypedTransaction::decode(&tx_rlp).unwrap();
+
+        {
+            let typed_tx: TypedTransaction = tx.clone().into();
+
+            let tx0: TransactionRequest = typed_tx.clone().into();
+            assert!(typed_tx.as_legacy_ref().is_err());
+
+            let tx1 = typed_tx.as_legacy();
+            let tx2 = typed_tx.into_legacy();
+
+            assert_eq!(tx0, tx1);
+            assert_eq!(tx1, tx2);
+        }
+        {
+            let typed_tx: TypedTransaction = tx.clone().into();
+            let tx0: Eip1559TransactionRequest = typed_tx.clone().into();
+            assert_eq!(tx.as_eip1559_ref().unwrap(), &tx0);
+
+            let tx1 = typed_tx.as_eip1559();
+            let tx2 = typed_tx.into_eip1559();
+
+            assert_eq!(tx0, tx1);
+            assert_eq!(tx1, tx2);
+        }
+        {
+            let typed_tx: TypedTransaction = tx.clone().into();
+            let tx0: Eip2930TransactionRequest = typed_tx.clone().into();
+            assert!(typed_tx.as_eip2930_ref().is_err());
+
+            let tx1 = typed_tx.as_eip2930();
+            let tx2 = typed_tx.into_eip2930();
+
+            assert_eq!(tx0, tx1);
+            assert_eq!(tx1, tx2);
+        }
+    }
 }