Prestwich/dyn sol error

crates/dyn-abi/src/arbitrary.rs

@@ -723,7 +723,9 @@ mod tests {
         match value {
             DynSolValue::Array(t)
             | DynSolValue::FixedArray(t)
-            | crate::ty::as_tuple!(DynSolValue t) => t.iter().try_for_each(assert_valid_value)?,
+            | crate::dynamic::ty::as_tuple!(DynSolValue t) => {
+                t.iter().try_for_each(assert_valid_value)?
+            }
             _ => {}
         }
 

crates/dyn-abi/src/coerce.rs

@@ -1,4 +1,4 @@
-use crate::{ty::as_tuple, DynSolType, DynSolValue, Result};
+use crate::{dynamic::ty::as_tuple, DynSolType, DynSolValue, Result};
 use alloc::vec::Vec;
 use alloy_primitives::{Address, FixedBytes, Function, Sign, I256, U256};
 use alloy_sol_types::Word;

crates/dyn-abi/src/dynamic/error.rs

@@ -0,0 +1,125 @@
+use crate::{DynSolType, DynSolValue, Error, Result};
+use alloc::vec::Vec;
+use alloy_primitives::{keccak256, Selector};
+use alloy_sol_types::SolError;
+
+/// See [alloy_sol_types::Panic] for signature details.
+const PANIC_SELECTOR: Selector = Selector::new(alloy_sol_types::Panic::SELECTOR);
+/// See [alloy_sol_types::Revert] for signature details.
+const REVERT_SELECTOR: Selector = Selector::new(alloy_sol_types::Revert::SELECTOR);
+
+/// A dynamic ABI error.
+///
+/// This is a representation of a Solidity error, which can be used to decode
+/// error events.
+#[derive(Debug, Clone, PartialEq)]
+pub struct DynSolError {
+    /// Error selector.
+    pub(crate) selector: Selector,
+    /// Error body types. MUST be a tuple.
+    pub(crate) body: DynSolType,
+}
+
+impl DynSolError {
+    /// Represents a standard Solidity revert. These are thrown by
+    /// `revert(reason)` or `require(condition, reason)` statements in Solidity.
+    ///
+    /// **Note**: Usage of this instantiator is not recommended. It is better to
+    /// use [alloy_sol_types::Revert] in almost all cases.
+    pub fn revert() -> Self {
+        Self { selector: REVERT_SELECTOR, body: DynSolType::Tuple(vec![DynSolType::String]) }
+    }
+
+    /// A [Solidity panic].
+    ///
+    /// **Note**: Usage of this instantiator is not recommended. It is better to
+    /// use [alloy_sol_types::Panic] in almost all cases.
+    ///
+    /// These are thrown by `assert(condition)` and by internal Solidity checks,
+    /// such as arithmetic overflow or array bounds checks.
+    ///
+    /// The list of all known panic codes can be found in the [PanicKind] enum.
+    ///
+    /// [Solidity panic]: https://docs.soliditylang.org/en/latest/control-structures.html#panic-via-assert-and-error-via-require
+    /// [PanicKind]: alloy_sol_types::PanicKind
+    pub fn panic() -> Self {
+        Self { selector: PANIC_SELECTOR, body: DynSolType::Tuple(vec![DynSolType::Uint(256)]) }
+    }
+
+    /// Creates a new error, without length-checking the body. This allows
+    /// creation of invalid errors.
+    pub const fn new_unchecked(selector: Selector, body: DynSolType) -> Self {
+        Self { selector, body }
+    }
+
+    /// Creates a new error from a selector.
+    pub fn new(selector: Selector, body: DynSolType) -> Option<Self> {
+        let _ = body.as_tuple()?;
+        Some(Self::new_unchecked(selector, body))
+    }
+
+    /// Error selector is the first 4 bytes of the keccak256 hash of the error
+    /// declaration.
+    pub const fn selector(&self) -> Selector {
+        self.selector
+    }
+
+    /// Error body types.
+    pub fn body(&self) -> &[DynSolType] {
+        self.body.as_tuple().expect("body is a tuple")
+    }
+
+    /// Decode the error from the given data, which must already be stripped of
+    /// its selector.
+    fn decode_error_body(&self, data: &[u8]) -> Result<DecodedError> {
+        let body = self.body.abi_decode_sequence(data)?.into_fixed_seq().expect("body is a tuple");
+        Ok(DecodedError { body })
+    }
+
+    /// Decode the error from the given data.
+    pub fn decode_error(&self, data: &[u8]) -> Result<DecodedError> {
+        // Check selector validity.
+        if !data.starts_with(self.selector.as_slice()) {
+            return Err(Error::SelectorMismatch {
+                expected: self.selector,
+                actual: Selector::from_slice(&data[0..4]),
+            });
+        }
+
+        // will not panic, as we've already checked the length with starts_with
+        let data = data.split_at(4).1;
+        self.decode_error_body(data)
+    }
+}
+
+/// A decoded dynamic ABI error.
+#[derive(Debug, Clone, PartialEq)]
+pub struct DecodedError {
+    /// The decoded error body.
+    pub body: Vec<DynSolValue>,
+}
+
+#[cfg(test)]
+mod test {
+    use super::DynSolError;
+    use crate::DynSolValue;
+    use alloy_primitives::hex;
+
+    #[test]
+    fn decode_revert_message() {
+        let error = DynSolError::revert();
+        let data = hex!("08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000042020202000000000000000000000000000000000000000000000000000000000");
+
+        let decoded = error.decode_error(&data).unwrap();
+        assert_eq!(decoded.body, vec!(DynSolValue::String("    ".into())));
+    }
+
+    #[test]
+    fn decode_panic() {
+        let error = DynSolError::panic();
+        let data = hex!("4e487b710000000000000000000000000000000000000000000000000000000000000001");
+
+        let decoded = error.decode_error(&data).unwrap();
+        assert_eq!(decoded.body, vec![DynSolValue::Uint(alloy_primitives::Uint::from(1), 256)]);
+    }
+}

crates/dyn-abi/src/event.rs → crates/dyn-abi/src/dynamic/event.rs

@@ -29,7 +29,8 @@ impl DynSolEvent {
     /// Checks that the indexed length is less than or equal to 4, and that the
     /// body is a tuple.
     pub fn new(topic_0: Option<B256>, indexed: Vec<DynSolType>, body: DynSolType) -> Option<Self> {
-        if indexed.len() > 4 || body.as_tuple().is_none() {
+        let topics = indexed.len() + topic_0.is_some() as usize;
+        if topics > 4 || body.as_tuple().is_none() {
             return None;
         }
         Some(Self::new_unchecked(topic_0, indexed, body))

crates/dyn-abi/src/dynamic/mod.rs

@@ -0,0 +1,14 @@
+mod error;
+pub use error::{DecodedError, DynSolError};
+
+mod event;
+pub use event::{DecodedEvent, DynSolEvent};
+
+pub(crate) mod ty;
+pub use ty::DynSolType;
+
+mod token;
+pub use token::DynToken;
+
+mod value;
+pub use value::DynSolValue;

crates/dyn-abi/src/error.rs

@@ -1,5 +1,5 @@
 use alloc::{borrow::Cow, string::String};
-use alloy_primitives::B256;
+use alloy_primitives::{Selector, B256};
 use alloy_sol_types::Error as SolTypesError;
 use core::fmt;
 use hex::FromHexError;
@@ -45,6 +45,15 @@ pub enum Error {
         /// The actual length.
         actual: usize,
     },
+
+    /// Selector mismatch during function or error decoding.
+    SelectorMismatch {
+        /// The expected selector.
+        expected: Selector,
+        /// The actual selector.
+        actual: Selector,
+    },
+
     /// Invalid event signature.
     EventSignatureMismatch {
         /// The expected signature.
@@ -126,7 +135,9 @@ impl fmt::Display for Error {
             Self::EventSignatureMismatch { expected, actual } => {
                 write!(f, "invalid event signature: expected {expected}, got {actual}",)
             }
-
+            Self::SelectorMismatch { expected, actual } => {
+                write!(f, "selector mismatch: expected {expected}, got {actual}",)
+            }
             Self::Hex(e) => e.fmt(f),
             Self::TypeParser(e) => e.fmt(f),
             Self::SolTypes(e) => e.fmt(f),

crates/dyn-abi/src/ext/error.rs

@@ -0,0 +1,36 @@
+use crate::{DynSolError, Specifier};
+use alloc::vec::Vec;
+use alloy_json_abi::Error;
+use alloy_primitives::{keccak256, Selector};
+
+mod sealed {
+    pub trait Sealed {}
+    impl Sealed for alloy_json_abi::Error {}
+}
+use sealed::Sealed;
+
+impl Specifier<DynSolError> for Error {
+    fn resolve(&self) -> crate::Result<DynSolError> {
+        let signature = self.signature();
+        let selector = Selector::from_slice(&keccak256(signature)[0..4]);
+
+        let mut body = Vec::with_capacity(self.inputs.len());
+        for param in &self.inputs {
+            body.push(param.resolve()?);
+        }
+
+        Ok(DynSolError::new_unchecked(selector, crate::DynSolType::Tuple(body)))
+    }
+}
+
+/// Provides error encoding and decoding for the [`Error`] type.
+pub trait ErrorExt: sealed::Sealed {
+    /// Decode the error from the given data.
+    fn decode_error(&self, data: &[u8]) -> crate::Result<crate::DecodedError>;
+}
+
+impl ErrorExt for alloy_json_abi::Error {
+    fn decode_error(&self, data: &[u8]) -> crate::Result<crate::DecodedError> {
+        self.resolve()?.decode_error(data)
+    }
+}

crates/dyn-abi/src/ext/event.rs

@@ -70,7 +70,7 @@ impl EventExt for Event {
     where
         I: IntoIterator<Item = B256>,
     {
-        Specifier::resolve(self)?.decode_log_parts(topics, data, validate)
+        self.resolve()?.decode_log_parts(topics, data, validate)
     }
 }
 

crates/dyn-abi/src/ext/mod.rs

@@ -3,3 +3,6 @@ pub use abi::{FunctionExt, JsonAbiExt};
 
 mod event;
 pub use event::EventExt;
+
+mod error;
+pub use error::ErrorExt;

crates/dyn-abi/src/lib.rs

@@ -36,26 +36,19 @@ mod arbitrary;
 
 mod coerce;
 
+mod dynamic;
+pub use dynamic::{
+    DecodedError, DecodedEvent, DynSolError, DynSolEvent, DynSolType, DynSolValue, DynToken,
+};
+
 mod error;
 pub use error::{Error, Result};
 
 mod ext;
-pub use ext::{EventExt, FunctionExt, JsonAbiExt};
-
-mod event;
-pub use event::{DecodedEvent, DynSolEvent};
-
-mod ty;
-pub use ty::DynSolType;
-
-mod value;
-pub use value::DynSolValue;
-
-mod token;
-pub use token::DynToken;
+pub use ext::{ErrorExt, EventExt, FunctionExt, JsonAbiExt};
 
-mod resolve;
-pub use resolve::Specifier;
+mod specifier;
+pub use specifier::Specifier;
 
 #[cfg(feature = "eip712")]
 pub mod eip712;