graph, chain/ethereum: Move declared call related structs to graph crate

Author: incrypto32

chain/ethereum/src/data_source.rs

@@ -5,21 +5,17 @@ use graph::components::metrics::subgraph::SubgraphInstanceMetrics;
 use graph::components::store::{EthereumCallCache, StoredDynamicDataSource};
 use graph::components::subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError};
 use graph::components::trigger_processor::RunnableTriggers;
-use graph::data::value::Word;
-use graph::data_source::common::{MappingABI, UnresolvedMappingABI};
+use graph::data_source::common::{CallDecls, MappingABI, UnresolvedMappingABI};
 use graph::data_source::CausalityRegion;
 use graph::env::ENV_VARS;
 use graph::futures03::future::try_join;
 use graph::futures03::stream::FuturesOrdered;
 use graph::futures03::TryStreamExt;
 use graph::prelude::ethabi::ethereum_types::H160;
 use graph::prelude::ethabi::{StateMutability, Token};
-use graph::prelude::lazy_static;
-use graph::prelude::regex::Regex;
 use graph::prelude::{Link, SubgraphManifestValidationError};
 use graph::slog::{debug, error, o, trace};
 use itertools::Itertools;
-use serde::de;
 use serde::de::Error as ErrorD;
 use serde::{Deserialize, Deserializer};
 use std::collections::HashSet;
@@ -31,7 +27,6 @@ use tiny_keccak::{keccak256, Keccak};
 
 use graph::{
     blockchain::{self, Blockchain},
-    derive::CheapClone,
     prelude::{
         async_trait,
         ethabi::{Address, Event, Function, LogParam, ParamType, RawLog},
@@ -1569,225 +1564,3 @@ fn string_to_h256(s: &str) -> H256 {
 pub struct TemplateSource {
     pub abi: String,
 }
-
-/// Internal representation of declared calls. In the manifest that's
-/// written as part of an event handler as
-/// ```yaml
-/// calls:
-///   - myCall1: Contract[address].function(arg1, arg2, ...)
-///   - ..
-/// ```
-///
-/// The `address` and `arg` fields can be either `event.address` or
-/// `event.params.<name>`. Each entry under `calls` gets turned into a
-/// `CallDcl`
-#[derive(Clone, CheapClone, Debug, Default, Hash, Eq, PartialEq)]
-pub struct CallDecls {
-    pub decls: Arc<Vec<CallDecl>>,
-    readonly: (),
-}
-
-/// A single call declaration, like `myCall1:
-/// Contract[address].function(arg1, arg2, ...)`
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-pub struct CallDecl {
-    /// A user-defined label
-    pub label: String,
-    /// The call expression
-    pub expr: CallExpr,
-    readonly: (),
-}
-impl CallDecl {
-    fn address(&self, log: &Log, params: &[LogParam]) -> Result<H160, Error> {
-        let address = match &self.expr.address {
-            CallArg::Address => log.address,
-            CallArg::HexAddress(address) => *address,
-            CallArg::Param(name) => {
-                let value = params
-                    .iter()
-                    .find(|param| &param.name == name.as_str())
-                    .ok_or_else(|| anyhow!("unknown param {name}"))?
-                    .value
-                    .clone();
-                value
-                    .into_address()
-                    .ok_or_else(|| anyhow!("param {name} is not an address"))?
-            }
-        };
-        Ok(address)
-    }
-
-    fn args(&self, log: &Log, params: &[LogParam]) -> Result<Vec<Token>, Error> {
-        self.expr
-            .args
-            .iter()
-            .map(|arg| match arg {
-                CallArg::Address => Ok(Token::Address(log.address)),
-                CallArg::HexAddress(address) => Ok(Token::Address(*address)),
-                CallArg::Param(name) => {
-                    let value = params
-                        .iter()
-                        .find(|param| &param.name == name.as_str())
-                        .ok_or_else(|| anyhow!("unknown param {name}"))?
-                        .value
-                        .clone();
-                    Ok(value)
-                }
-            })
-            .collect()
-    }
-}
-
-impl<'de> de::Deserialize<'de> for CallDecls {
-    fn deserialize<D>(deserializer: D) -> Result<CallDecls, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        let decls: std::collections::HashMap<String, String> =
-            de::Deserialize::deserialize(deserializer)?;
-        let decls = decls
-            .into_iter()
-            .map(|(name, expr)| {
-                expr.parse::<CallExpr>().map(|expr| CallDecl {
-                    label: name,
-                    expr,
-                    readonly: (),
-                })
-            })
-            .collect::<Result<_, _>>()
-            .map(|decls| Arc::new(decls))
-            .map_err(de::Error::custom)?;
-        Ok(CallDecls {
-            decls,
-            readonly: (),
-        })
-    }
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-pub struct CallExpr {
-    pub abi: Word,
-    pub address: CallArg,
-    pub func: Word,
-    pub args: Vec<CallArg>,
-    readonly: (),
-}
-
-/// Parse expressions of the form `Contract[address].function(arg1, arg2,
-/// ...)` where the `address` and the args are either `event.address` or
-/// `event.params.<name>`.
-///
-/// The parser is pretty awful as it generates error messages that aren't
-/// very helpful. We should replace all this with a real parser, most likely
-/// `combine` which is what `graphql_parser` uses
-impl FromStr for CallExpr {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        lazy_static! {
-            static ref RE: Regex = Regex::new(
-                r"(?x)
-                (?P<abi>[a-zA-Z0-9_]+)\[
-                    (?P<address>[^]]+)\]
-                \.
-                (?P<func>[a-zA-Z0-9_]+)\(
-                    (?P<args>[^)]*)
-                \)"
-            )
-            .unwrap();
-        }
-        let x = RE
-            .captures(s)
-            .ok_or_else(|| anyhow!("invalid call expression `{s}`"))?;
-        let abi = Word::from(x.name("abi").unwrap().as_str());
-        let address = x.name("address").unwrap().as_str().parse()?;
-        let func = Word::from(x.name("func").unwrap().as_str());
-        let args: Vec<CallArg> = x
-            .name("args")
-            .unwrap()
-            .as_str()
-            .split(',')
-            .filter(|s| !s.is_empty())
-            .map(|s| s.trim().parse::<CallArg>())
-            .collect::<Result<_, _>>()?;
-        Ok(CallExpr {
-            abi,
-            address,
-            func,
-            args,
-            readonly: (),
-        })
-    }
-}
-
-#[derive(Clone, Debug, Hash, Eq, PartialEq)]
-pub enum CallArg {
-    HexAddress(Address),
-    Address,
-    Param(Word),
-}
-
-lazy_static! {
-    // Matches a 40-character hexadecimal string prefixed with '0x', typical for Ethereum addresses
-    static ref ADDR_RE: Regex = Regex::new(r"^0x[0-9a-fA-F]{40}$").unwrap();
-}
-
-impl FromStr for CallArg {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if ADDR_RE.is_match(s) {
-            if let Ok(parsed_address) = Address::from_str(s) {
-                return Ok(CallArg::HexAddress(parsed_address));
-            }
-        }
-
-        let mut parts = s.split('.');
-        match (parts.next(), parts.next(), parts.next()) {
-            (Some("event"), Some("address"), None) => Ok(CallArg::Address),
-            (Some("event"), Some("params"), Some(param)) => Ok(CallArg::Param(Word::from(param))),
-            _ => Err(anyhow!("invalid call argument `{}`", s)),
-        }
-    }
-}
-
-#[test]
-fn test_call_expr() {
-    let expr: CallExpr = "ERC20[event.address].balanceOf(event.params.token)"
-        .parse()
-        .unwrap();
-    assert_eq!(expr.abi, "ERC20");
-    assert_eq!(expr.address, CallArg::Address);
-    assert_eq!(expr.func, "balanceOf");
-    assert_eq!(expr.args, vec![CallArg::Param("token".into())]);
-
-    let expr: CallExpr = "Pool[event.params.pool].fees(event.params.token0, event.params.token1)"
-        .parse()
-        .unwrap();
-    assert_eq!(expr.abi, "Pool");
-    assert_eq!(expr.address, CallArg::Param("pool".into()));
-    assert_eq!(expr.func, "fees");
-    assert_eq!(
-        expr.args,
-        vec![
-            CallArg::Param("token0".into()),
-            CallArg::Param("token1".into())
-        ]
-    );
-
-    let expr: CallExpr = "Pool[event.address].growth()".parse().unwrap();
-    assert_eq!(expr.abi, "Pool");
-    assert_eq!(expr.address, CallArg::Address);
-    assert_eq!(expr.func, "growth");
-    assert_eq!(expr.args, vec![]);
-
-    let expr: CallExpr = "Pool[0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF].growth(0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF)"
-        .parse()
-        .unwrap();
-    let call_arg =
-        CallArg::HexAddress(H160::from_str("0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF").unwrap());
-    assert_eq!(expr.abi, "Pool");
-    assert_eq!(expr.address, call_arg);
-    assert_eq!(expr.func, "growth");
-    assert_eq!(expr.args, vec![call_arg]);
-}