ethereum: Fix adapter to filter proxy calls (#3219)

* ethereum: Fix adapter to filter proxy calls

Without this the line that does `function_abi.decode_input(&call.input.0[4..])`
was failing with the Err(InvalidData).

For some reason some of the OpenSea Proxy contracts don't get recognized
as DELEGATECALL, instead they are seen as CALLs, but you can identify
them by the input having the wrong size since it's a fallback function
call.

A scenario to exemplify the problem, can be seen in this transaction:
0x4499dc75facb4cd27894196aac00bcb0ffbe3d64de87105878451d5637662f90

We would get the traces for the block 14043345 (0xD648D1) for the
contract 0x7Be8076f4EA4A4AD08075C2508e481d6C946D12b. Then we would
find two CALLs for the `atomicMatch_` function. However the first one
would have the wrong size (fail at decoding) and the second one would be
correct.

That's because of the proxy and because of how fallbacks are compiled
from Solidity (omitting the function signature, aka a feel bytes less).

* ethereum: Apply code review suggestions for the adapter

* ethereum: Elaborate/improve comment about call input size

Author: evaporei

chain/ethereum/src/adapter.rs

@@ -304,23 +304,35 @@ impl EthereumCallFilter {
         }
 
         // Ensure the call is to a contract the filter expressed an interest in
-        match self.contract_addresses_function_signatures.get(&call.to) {
-            None => false,
-            Some(v) => {
-                let signature = &v.1;
-
-                // If the call is to a contract with no specified functions, keep the call
-                //
-                // Allows the ability to genericly match on all calls to a contract.
-                // Caveat is this catch all clause limits you from matching with a specific call
-                // on the same address
-                if signature.is_empty() {
-                    true
-                } else {
-                    // Ensure the call is to run a function the filter expressed an interest in
-                    signature.contains(&call.input.0[..4])
-                }
-            }
+        let signature = match self.contract_addresses_function_signatures.get(&call.to) {
+            None => return false,
+            Some(v) => &v.1,
+        };
+
+        // If the call is to a contract with no specified functions, keep the call
+        //
+        // Allows the ability to genericly match on all calls to a contract.
+        // Caveat is this catch all clause limits you from matching with a specific call
+        // on the same address
+        if signature.is_empty() {
+            true
+        } else {
+            // Ensure the call is to run a function the filter expressed an interest in
+            let correct_fn = signature.contains(&call.input.0[..4]);
+            // Make sure the call input size is multiple of 32, otherwise we can't decode it.
+            // This is due to the Ethereum ABI spec: https://docs.soliditylang.org/en/v0.8.11/abi-spec.html
+            //
+            // A scenario where the input could have the wrong size is when a `delegatecall` is
+            // "disguised" as a `call`. For example for this couple of transactions/calls:
+            // 1. https://etherscan.io/tx/0x8e992eeb40e18703dd8169a8031e2113311985f1c20e0723a2dc362df40bafb0
+            // 2. https://etherscan.io/tx/0x7c391bcfa2007f84e123ad47ea72e2d6ffb2fbab81deff0990b0c499e0664a92
+            //
+            // The first one is acting as a proxy to the second one (an atomicMatch_).
+            // If you try to decode the first call as it is/comes from a `traces` RPC request, it
+            // will fail because it has a smaller size/length.
+            let correct_input_size = (call.input.0.len() - 4) % 32 == 0;
+
+            correct_fn && correct_input_size
         }
     }
 
@@ -714,6 +726,12 @@ mod tests {
             "call with correct address & signature should match"
         );
 
+        assert_eq!(
+            false,
+            filter.matches(&call(address(1), vec![1; 32])),
+            "call with correct address & signature, but with incorrect input size should be ignored"
+        );
+
         assert_eq!(
             false,
             filter.matches(&call(address(1), vec![4u8; 36])),