diff --git a/chain/ethereum/src/data_source.rs b/chain/ethereum/src/data_source.rs index a2da3e6cb4e..7cfb1153434 100644 --- a/chain/ethereum/src/data_source.rs +++ b/chain/ethereum/src/data_source.rs @@ -6,7 +6,8 @@ use graph::components::store::{EthereumCallCache, StoredDynamicDataSource}; use graph::components::subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError}; use graph::components::trigger_processor::RunnableTriggers; use graph::data_source::common::{ - CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedMappingABI, + AbiJson, CallDecls, DeclaredCall, FindMappingABI, MappingABI, UnresolvedCallDecls, + UnresolvedMappingABI, }; use graph::data_source::{CausalityRegion, MappingTrigger as MappingTriggerType}; use graph::env::ENV_VARS; @@ -800,7 +801,7 @@ impl DataSource { "transaction" => format!("{}", &transaction.hash), }); let handler = event_handler.handler.clone(); - let calls = DeclaredCall::from_log_trigger( + let calls = DeclaredCall::from_log_trigger_with_event( &self.mapping, &event_handler.calls, &log, @@ -1200,6 +1201,7 @@ impl blockchain::UnresolvedDataSource for UnresolvedDataSource { resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result { let UnresolvedDataSource { kind, @@ -1210,7 +1212,7 @@ impl blockchain::UnresolvedDataSource for UnresolvedDataSource { context, } = self; - let mapping = mapping.resolve(resolver, logger).await.with_context(|| { + let mapping = mapping.resolve(resolver, logger, spec_version).await.with_context(|| { format!( "failed to resolve data source {} with source_address {:?} and source_start_block {}", name, source.address, source.start_block @@ -1221,7 +1223,7 @@ impl blockchain::UnresolvedDataSource for UnresolvedDataSource { } } -#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)] +#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)] pub struct UnresolvedDataSourceTemplate { pub kind: String, pub network: Option, @@ -1247,6 +1249,7 @@ impl blockchain::UnresolvedDataSourceTemplate for UnresolvedDataSourceTem resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result { let UnresolvedDataSourceTemplate { kind, @@ -1257,7 +1260,7 @@ impl blockchain::UnresolvedDataSourceTemplate for UnresolvedDataSourceTem } = self; let mapping = mapping - .resolve(resolver, logger) + .resolve(resolver, logger, spec_version) .await .with_context(|| format!("failed to resolve data source template {}", name))?; @@ -1294,7 +1297,7 @@ impl blockchain::DataSourceTemplate for DataSourceTemplate { } } -#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)] +#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)] #[serde(rename_all = "camelCase")] pub struct UnresolvedMapping { pub kind: String, @@ -1307,7 +1310,7 @@ pub struct UnresolvedMapping { #[serde(default)] pub call_handlers: Vec, #[serde(default)] - pub event_handlers: Vec, + pub event_handlers: Vec, pub file: Link, } @@ -1357,6 +1360,7 @@ impl UnresolvedMapping { self, resolver: &Arc, logger: &Logger, + spec_version: &semver::Version, ) -> Result { let UnresolvedMapping { kind, @@ -1376,9 +1380,7 @@ impl UnresolvedMapping { // resolve each abi abis.into_iter() .map(|unresolved_abi| async { - Result::<_, Error>::Ok(Arc::new( - unresolved_abi.resolve(resolver, logger).await?, - )) + Result::<_, Error>::Ok(unresolved_abi.resolve(resolver, logger).await?) }) .collect::>() .try_collect::>(), @@ -1390,15 +1392,35 @@ impl UnresolvedMapping { .await .with_context(|| format!("failed to resolve mapping {}", link.link))?; + // Resolve event handlers with ABI context + let resolved_event_handlers = event_handlers + .into_iter() + .map(|unresolved_handler| { + // Find the ABI for this event handler + let (_, abi_json) = abis.first().ok_or_else(|| { + anyhow!( + "No ABI found for event '{}' in event handler '{}'", + unresolved_handler.event, + unresolved_handler.handler + ) + })?; + + unresolved_handler.resolve(abi_json, &spec_version) + }) + .collect::, anyhow::Error>>()?; + + // Extract just the MappingABIs for the final Mapping struct + let mapping_abis = abis.into_iter().map(|(abi, _)| Arc::new(abi)).collect(); + Ok(Mapping { kind, api_version, language, entities, - abis, + abis: mapping_abis, block_handlers: block_handlers.clone(), call_handlers: call_handlers.clone(), - event_handlers: event_handlers.clone(), + event_handlers: resolved_event_handlers, runtime, link, }) @@ -1442,8 +1464,8 @@ pub struct MappingCallHandler { pub handler: String, } -#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)] -pub struct MappingEventHandler { +#[derive(Clone, Debug, Eq, PartialEq, Deserialize)] +pub struct UnresolvedMappingEventHandler { pub event: String, pub topic0: Option, #[serde(deserialize_with = "deserialize_h256_vec", default)] @@ -1456,6 +1478,41 @@ pub struct MappingEventHandler { #[serde(default)] pub receipt: bool, #[serde(default)] + pub calls: UnresolvedCallDecls, +} + +impl UnresolvedMappingEventHandler { + pub fn resolve( + self, + abi_json: &AbiJson, + spec_version: &semver::Version, + ) -> Result { + let resolved_calls = self + .calls + .resolve(abi_json, Some(&self.event), spec_version)?; + + Ok(MappingEventHandler { + event: self.event, + topic0: self.topic0, + topic1: self.topic1, + topic2: self.topic2, + topic3: self.topic3, + handler: self.handler, + receipt: self.receipt, + calls: resolved_calls, + }) + } +} + +#[derive(Clone, Debug, Hash, Eq, PartialEq)] +pub struct MappingEventHandler { + pub event: String, + pub topic0: Option, + pub topic1: Option>, + pub topic2: Option>, + pub topic3: Option>, + pub handler: String, + pub receipt: bool, pub calls: CallDecls, } diff --git a/chain/near/src/data_source.rs b/chain/near/src/data_source.rs index ea54c31d157..46d84dc1e3c 100644 --- a/chain/near/src/data_source.rs +++ b/chain/near/src/data_source.rs @@ -333,6 +333,7 @@ impl blockchain::UnresolvedDataSource for UnresolvedDataSource { resolver: &Arc, logger: &Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { let UnresolvedDataSource { kind, @@ -372,6 +373,7 @@ impl blockchain::UnresolvedDataSourceTemplate for UnresolvedDataSourceTem resolver: &Arc, logger: &Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { let UnresolvedDataSourceTemplate { kind, diff --git a/chain/substreams/src/data_source.rs b/chain/substreams/src/data_source.rs index 3969f83e373..4895d76a8c6 100644 --- a/chain/substreams/src/data_source.rs +++ b/chain/substreams/src/data_source.rs @@ -187,6 +187,7 @@ impl blockchain::UnresolvedDataSource for UnresolvedDataSource { resolver: &Arc, logger: &Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { let content = resolver.cat(logger, &self.source.package.file).await?; @@ -317,6 +318,7 @@ impl blockchain::UnresolvedDataSourceTemplate for NoopDataSourceTemplate _resolver: &Arc, _logger: &Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { unimplemented!("{}", TEMPLATE_ERROR) } @@ -330,7 +332,7 @@ mod test { use graph::{ blockchain::{DataSource as _, UnresolvedDataSource as _}, components::link_resolver::LinkResolver, - data::subgraph::LATEST_VERSION, + data::subgraph::{LATEST_VERSION, SPEC_VERSION_1_2_0}, prelude::{async_trait, serde_yaml, JsonValueStream, Link}, slog::{o, Discard, Logger}, substreams::{ @@ -433,7 +435,10 @@ mod test { let ds: UnresolvedDataSource = serde_yaml::from_str(TEMPLATE_DATA_SOURCE).unwrap(); let link_resolver: Arc = Arc::new(NoopLinkResolver {}); let logger = Logger::root(Discard, o!()); - let ds: DataSource = ds.resolve(&link_resolver, &logger, 0).await.unwrap(); + let ds: DataSource = ds + .resolve(&link_resolver, &logger, 0, &SPEC_VERSION_1_2_0) + .await + .unwrap(); let expected = DataSource { kind: SUBSTREAMS_KIND.into(), network: Some("mainnet".into()), @@ -470,7 +475,10 @@ mod test { serde_yaml::from_str(TEMPLATE_DATA_SOURCE_WITH_PARAMS).unwrap(); let link_resolver: Arc = Arc::new(NoopLinkResolver {}); let logger = Logger::root(Discard, o!()); - let ds: DataSource = ds.resolve(&link_resolver, &logger, 0).await.unwrap(); + let ds: DataSource = ds + .resolve(&link_resolver, &logger, 0, &SPEC_VERSION_1_2_0) + .await + .unwrap(); let expected = DataSource { kind: SUBSTREAMS_KIND.into(), network: Some("mainnet".into()), diff --git a/docs/subgraph-manifest.md b/docs/subgraph-manifest.md index 4f766829cfc..caad7943e84 100644 --- a/docs/subgraph-manifest.md +++ b/docs/subgraph-manifest.md @@ -98,7 +98,7 @@ The `mapping` field may be one of the following supported mapping manifests: ### 1.5.3 Declaring calls -_Available from spec version 1.2.0_ +_Available from spec version 1.2.0. Struct field access available from spec version 1.4.0_ Declared calls are performed in parallel before the handler is run and can greatly speed up syncing. Mappings access the call results simply by using @@ -118,7 +118,17 @@ Each call is of the form `[
].()`: | **function** | *String* | The name of a view function in the contract | | **args** | *[Expr]* | The arguments to pass to the function | -The `Expr` can be either `event.address` or `event.params.`. +#### Expression Types + +The `Expr` can be one of the following: + +| Expression | Description | +| --- | --- | +| **event.address** | The address of the contract that emitted the event | +| **event.params.<name>** | A simple parameter from the event | +| **event.params.<name>.<index>** | A field from a struct parameter by numeric index | +| **event.params.<name>.<fieldName>** | A field from a struct parameter by field name (spec version 1.4.0+) | + ## 1.6 Path A path has one field `path`, which either refers to a path of a file on the local dev machine or an [IPLD link](https://github.com/ipld/specs/). diff --git a/graph/src/blockchain/mock.rs b/graph/src/blockchain/mock.rs index 01487c42113..8ee6ddf6fec 100644 --- a/graph/src/blockchain/mock.rs +++ b/graph/src/blockchain/mock.rs @@ -193,6 +193,7 @@ impl UnresolvedDataSource for MockUnresolvedDataSource { _resolver: &Arc, _logger: &slog::Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { todo!() } @@ -243,6 +244,7 @@ impl UnresolvedDataSourceTemplate for MockUnresolvedDataSource _resolver: &Arc, _logger: &slog::Logger, _manifest_idx: u32, + _spec_version: &semver::Version, ) -> Result { todo!() } diff --git a/graph/src/blockchain/mod.rs b/graph/src/blockchain/mod.rs index 00a9ac33e4e..eab4ef8ea7c 100644 --- a/graph/src/blockchain/mod.rs +++ b/graph/src/blockchain/mod.rs @@ -378,6 +378,7 @@ pub trait UnresolvedDataSourceTemplate: resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result; } @@ -407,6 +408,7 @@ pub trait UnresolvedDataSource: resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result; } diff --git a/graph/src/data/subgraph/api_version.rs b/graph/src/data/subgraph/api_version.rs index fbda95b2792..5a74e216096 100644 --- a/graph/src/data/subgraph/api_version.rs +++ b/graph/src/data/subgraph/api_version.rs @@ -60,8 +60,11 @@ pub const SPEC_VERSION_1_2_0: Version = Version::new(1, 2, 0); // represents the write order across all entity types in the subgraph. pub const SPEC_VERSION_1_3_0: Version = Version::new(1, 3, 0); +// Enables struct field access in declarative calls +pub const SPEC_VERSION_1_4_0: Version = Version::new(1, 4, 0); + // The latest spec version available -pub const LATEST_VERSION: &Version = &SPEC_VERSION_1_3_0; +pub const LATEST_VERSION: &Version = &SPEC_VERSION_1_4_0; pub const MIN_SPEC_VERSION: Version = Version::new(0, 0, 2); diff --git a/graph/src/data/subgraph/mod.rs b/graph/src/data/subgraph/mod.rs index 10c4e471e38..068b390bf64 100644 --- a/graph/src/data/subgraph/mod.rs +++ b/graph/src/data/subgraph/mod.rs @@ -1074,14 +1074,20 @@ impl UnresolvedSubgraphManifest { data_sources .into_iter() .enumerate() - .map(|(idx, ds)| ds.resolve(resolver, logger, idx as u32)) + .map(|(idx, ds)| ds.resolve(resolver, logger, idx as u32, &spec_version)) .collect::>() .try_collect::>(), templates .into_iter() .enumerate() .map(|(idx, template)| { - template.resolve(resolver, &schema, logger, ds_count as u32 + idx as u32) + template.resolve( + resolver, + &schema, + logger, + ds_count as u32 + idx as u32, + &spec_version, + ) }) .collect::>() .try_collect::>(), diff --git a/graph/src/data_source/common.rs b/graph/src/data_source/common.rs index 57781815f5f..9f22f109860 100644 --- a/graph/src/data_source/common.rs +++ b/graph/src/data_source/common.rs @@ -1,4 +1,5 @@ use crate::blockchain::block_stream::EntitySourceOperation; +use crate::data::subgraph::SPEC_VERSION_1_4_0; use crate::prelude::{BlockPtr, Value}; use crate::{components::link_resolver::LinkResolver, data::value::Word, prelude::Link}; use anyhow::{anyhow, Context, Error}; @@ -9,7 +10,9 @@ use num_bigint::Sign; use regex::Regex; use serde::de; use serde::Deserialize; +use serde_json; use slog::Logger; +use std::collections::HashMap; use std::{str::FromStr, sync::Arc}; use web3::types::{Log, H160}; @@ -63,6 +66,268 @@ impl MappingABI { } } +/// Helper struct for working with ABI JSON to extract struct field information on demand +#[derive(Clone, Debug)] +pub struct AbiJson { + abi: serde_json::Value, +} + +impl AbiJson { + pub fn new(abi_bytes: &[u8]) -> Result { + let abi = serde_json::from_slice(abi_bytes).with_context(|| "Failed to parse ABI JSON")?; + Ok(Self { abi }) + } + + /// Extract event name from event signature + /// e.g., "Transfer(address,address,uint256)" -> "Transfer" + fn extract_event_name(signature: &str) -> &str { + signature.split('(').next().unwrap_or(signature).trim() + } + + /// Get struct field information for a specific event parameter + pub fn get_struct_field_info( + &self, + event_signature: &str, + param_name: &str, + ) -> Result, Error> { + let event_name = Self::extract_event_name(event_signature); + + let Some(abi_array) = self.abi.as_array() else { + return Ok(None); + }; + + for item in abi_array { + // Only process events + if item.get("type").and_then(|t| t.as_str()) == Some("event") { + if let Some(item_event_name) = item.get("name").and_then(|n| n.as_str()) { + if item_event_name == event_name { + // Found the event, now look for the parameter + if let Some(inputs) = item.get("inputs").and_then(|i| i.as_array()) { + for input in inputs { + if let Some(input_param_name) = + input.get("name").and_then(|n| n.as_str()) + { + if input_param_name == param_name { + // Found the parameter, check if it's a struct + if let Some(param_type) = + input.get("type").and_then(|t| t.as_str()) + { + if param_type == "tuple" { + if let Some(components) = input.get("components") { + // Parse the ParamType from the JSON (simplified for now) + let param_type = ParamType::Tuple(vec![]); + return StructFieldInfo::from_components( + param_name.to_string(), + param_type, + components, + ) + .map(Some); + } + } + } + // Parameter found but not a struct + return Ok(None); + } + } + } + } + // Event found but parameter not found + return Ok(None); + } + } + } + } + + // Event not found + Ok(None) + } + + /// Get nested struct field information by resolving a field path + /// e.g., field_path = ["complexAsset", "base", "addr"] + /// returns Some(vec![0, 0]) if complexAsset.base is at index 0 and base.addr is at index 0 + pub fn get_nested_struct_field_info( + &self, + event_signature: &str, + field_path: &[&str], + ) -> Result>, Error> { + if field_path.is_empty() { + return Ok(None); + } + + let event_name = Self::extract_event_name(event_signature); + let param_name = field_path[0]; + let nested_path = &field_path[1..]; + + let Some(abi_array) = self.abi.as_array() else { + return Ok(None); + }; + + for item in abi_array { + // Only process events + if item.get("type").and_then(|t| t.as_str()) == Some("event") { + if let Some(item_event_name) = item.get("name").and_then(|n| n.as_str()) { + if item_event_name == event_name { + // Found the event, now look for the parameter + if let Some(inputs) = item.get("inputs").and_then(|i| i.as_array()) { + for input in inputs { + if let Some(input_param_name) = + input.get("name").and_then(|n| n.as_str()) + { + if input_param_name == param_name { + // Found the parameter, check if it's a struct + if let Some(param_type) = + input.get("type").and_then(|t| t.as_str()) + { + if param_type == "tuple" { + if let Some(components) = input.get("components") { + // If no nested path, this is the end + if nested_path.is_empty() { + return Ok(Some(vec![])); + } + // Recursively resolve the nested path + return self + .resolve_field_path(components, nested_path) + .map(Some); + } + } + } + // Parameter found but not a struct + return Ok(None); + } + } + } + } + // Event found but parameter not found + return Ok(None); + } + } + } + } + + // Event not found + Ok(None) + } + + /// Recursively resolve a field path within ABI components + /// Supports both numeric indices and field names + /// Returns the index path to access the final field + fn resolve_field_path( + &self, + components: &serde_json::Value, + field_path: &[&str], + ) -> Result, Error> { + if field_path.is_empty() { + return Ok(vec![]); + } + + let field_accessor = field_path[0]; + let remaining_path = &field_path[1..]; + + let Some(components_array) = components.as_array() else { + return Err(anyhow!("Expected components array")); + }; + + // Check if it's a numeric index + if let Ok(index) = field_accessor.parse::() { + // Validate the index + if index >= components_array.len() { + return Err(anyhow!( + "Index {} out of bounds for struct with {} fields", + index, + components_array.len() + )); + } + + // If there are more fields to resolve + if !remaining_path.is_empty() { + let component = &components_array[index]; + + // Check if this component is a tuple that can be further accessed + if let Some(component_type) = component.get("type").and_then(|t| t.as_str()) { + if component_type == "tuple" { + if let Some(nested_components) = component.get("components") { + // Recursively resolve the remaining path + let mut result = vec![index]; + let nested_result = + self.resolve_field_path(nested_components, remaining_path)?; + result.extend(nested_result); + return Ok(result); + } else { + return Err(anyhow!( + "Field at index {} is a tuple but has no components", + index + )); + } + } else { + return Err(anyhow!( + "Field at index {} is not a struct (type: {}), cannot access nested field '{}'", + index, + component_type, + remaining_path[0] + )); + } + } + } + + // This is the final field + return Ok(vec![index]); + } + + // It's a field name - find it in the current level + for (index, component) in components_array.iter().enumerate() { + if let Some(component_name) = component.get("name").and_then(|n| n.as_str()) { + if component_name == field_accessor { + // Found the field + if remaining_path.is_empty() { + // This is the final field, return its index + return Ok(vec![index]); + } else { + // We need to go deeper - check if this component is a tuple + if let Some(component_type) = component.get("type").and_then(|t| t.as_str()) + { + if component_type == "tuple" { + if let Some(nested_components) = component.get("components") { + // Recursively resolve the remaining path + let mut result = vec![index]; + let nested_result = + self.resolve_field_path(nested_components, remaining_path)?; + result.extend(nested_result); + return Ok(result); + } else { + return Err(anyhow!( + "Tuple field '{}' has no components", + field_accessor + )); + } + } else { + return Err(anyhow!( + "Field '{}' is not a struct (type: {}), cannot access nested field '{}'", + field_accessor, + component_type, + remaining_path[0] + )); + } + } + } + } + } + } + + // Field not found at this level + let available_fields: Vec = components_array + .iter() + .filter_map(|c| c.get("name").and_then(|n| n.as_str())) + .map(String::from) + .collect(); + + Err(anyhow!( + "Field '{}' not found. Available fields: {:?}", + field_accessor, + available_fields + )) + } +} + #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)] pub struct UnresolvedMappingABI { pub name: String, @@ -74,7 +339,7 @@ impl UnresolvedMappingABI { self, resolver: &Arc, logger: &Logger, - ) -> Result { + ) -> Result<(MappingABI, AbiJson), anyhow::Error> { let contract_bytes = resolver.cat(logger, &self.file).await.with_context(|| { format!( "failed to resolve ABI {} from {}", @@ -83,10 +348,18 @@ impl UnresolvedMappingABI { })?; let contract = Contract::load(&*contract_bytes) .with_context(|| format!("failed to load ABI {}", self.name))?; - Ok(MappingABI { - name: self.name, - contract, - }) + + // Parse ABI JSON for on-demand struct field extraction + let abi_json = AbiJson::new(&contract_bytes) + .with_context(|| format!("Failed to parse ABI JSON for {}", self.name))?; + + Ok(( + MappingABI { + name: self.name, + contract, + }, + abi_json, + )) } } @@ -124,6 +397,10 @@ impl CallDecl { } pub fn address_for_log(&self, log: &Log, params: &[LogParam]) -> Result { + self.address_for_log_with_abi(log, params) + } + + pub fn address_for_log_with_abi(&self, log: &Log, params: &[LogParam]) -> Result { let address = match &self.expr.address { CallArg::HexAddress(address) => *address, CallArg::Ethereum(arg) => match arg { @@ -132,24 +409,61 @@ impl CallDecl { let value = params .iter() .find(|param| ¶m.name == name.as_str()) - .ok_or_else(|| anyhow!("unknown param {name}"))? + .ok_or_else(|| { + anyhow!( + "In declarative call '{}': unknown param {}", + self.label, + name + ) + })? .value .clone(); - value - .into_address() - .ok_or_else(|| anyhow!("param {name} is not an address"))? + value.into_address().ok_or_else(|| { + anyhow!( + "In declarative call '{}': param {} is not an address", + self.label, + name + ) + })? + } + EthereumArg::StructField(param_name, field_accesses) => { + let param = params + .iter() + .find(|param| ¶m.name == param_name.as_str()) + .ok_or_else(|| { + anyhow!( + "In declarative call '{}': unknown param {}", + self.label, + param_name + ) + })?; + + Self::extract_nested_struct_field_as_address( + ¶m.value, + field_accesses, + &self.label, + )? } }, CallArg::Subgraph(_) => { return Err(anyhow!( - "Subgraph params are not supported for when declaring calls for event handlers" - )) + "In declarative call '{}': Subgraph params are not supported for event handlers", + self.label + )) } }; Ok(address) } pub fn args_for_log(&self, log: &Log, params: &[LogParam]) -> Result, Error> { + self.args_for_log_with_abi(log, params) + } + + pub fn args_for_log_with_abi( + &self, + log: &Log, + params: &[LogParam], + ) -> Result, Error> { self.expr .args .iter() @@ -161,14 +475,27 @@ impl CallDecl { let value = params .iter() .find(|param| ¶m.name == name.as_str()) - .ok_or_else(|| anyhow!("unknown param {name}"))? + .ok_or_else(|| anyhow!("In declarative call '{}': unknown param {}", self.label, name))? .value .clone(); Ok(value) } + EthereumArg::StructField(param_name, field_accesses) => { + let param = params + .iter() + .find(|param| ¶m.name == param_name.as_str()) + .ok_or_else(|| anyhow!("In declarative call '{}': unknown param {}", self.label, param_name))?; + + Self::extract_nested_struct_field( + ¶m.value, + field_accesses, + &self.label, + ) + } }, CallArg::Subgraph(_) => Err(anyhow!( - "Subgraph params are not supported for when declaring calls for event handlers" + "In declarative call '{}': Subgraph params are not supported for event handlers", + self.label )), }) .collect() @@ -357,29 +684,121 @@ impl CallDecl { .collect(); Ok(Token::Array(tokens?)) } + + /// Extracts a nested field value from a struct parameter with mixed numeric/named access + fn extract_nested_struct_field_as_address( + struct_token: &Token, + field_accesses: &[usize], + call_label: &str, + ) -> Result { + let field_token = + Self::extract_nested_struct_field(struct_token, field_accesses, call_label)?; + field_token.into_address().ok_or_else(|| { + anyhow!( + "In declarative call '{}': nested struct field is not an address", + call_label + ) + }) + } + + /// Extracts a nested field value from a struct parameter using numeric indices + fn extract_nested_struct_field( + struct_token: &Token, + field_accesses: &[usize], + call_label: &str, + ) -> Result { + assert!( + !field_accesses.is_empty(), + "Internal error: empty field access path should be caught at parse time" + ); + + let mut current_token = struct_token; + + for (index, &field_index) in field_accesses.iter().enumerate() { + match current_token { + Token::Tuple(fields) => { + let field_token = fields + .get(field_index) + .ok_or_else(|| { + anyhow!( + "In declarative call '{}': struct field index {} out of bounds (struct has {} fields) at access step {}", + call_label, field_index, fields.len(), index + ) + })?; + + // If this is the last field access, return the token + if index == field_accesses.len() - 1 { + return Ok(field_token.clone()); + } + + // Otherwise, continue with the next level + current_token = field_token; + } + _ => { + return Err(anyhow!( + "In declarative call '{}': cannot access field on non-struct/tuple at access step {} (field path: {:?})", + call_label, index, field_accesses + )); + } + } + } + + // This should never be reached due to empty check at the beginning + unreachable!() + } +} + +/// Unresolved representation of declared calls stored as raw strings +/// Used during initial manifest parsing before ABI context is available +#[derive(Clone, CheapClone, Debug, Default, Eq, PartialEq)] +pub struct UnresolvedCallDecls { + pub raw_decls: Arc>, + readonly: (), } -impl<'de> de::Deserialize<'de> for CallDecls { - fn deserialize(deserializer: D) -> Result +impl UnresolvedCallDecls { + /// Parse the raw call declarations into CallDecls using ABI context + pub fn resolve( + self, + abi_json: &AbiJson, + event_signature: Option<&str>, + spec_version: &semver::Version, + ) -> Result { + let decls: Result, anyhow::Error> = self + .raw_decls + .iter() + .map(|(label, expr)| { + CallExpr::parse(expr, abi_json, event_signature, spec_version) + .map(|expr| CallDecl { + label: label.clone(), + expr, + readonly: (), + }) + .with_context(|| format!("Error in declared call '{}':", label)) + }) + .collect(); + + Ok(CallDecls { + decls: Arc::new(decls?), + readonly: (), + }) + } + + /// Check if the unresolved calls are empty + pub fn is_empty(&self) -> bool { + self.raw_decls.is_empty() + } +} + +impl<'de> de::Deserialize<'de> for UnresolvedCallDecls { + fn deserialize(deserializer: D) -> Result where D: de::Deserializer<'de>, { - let decls: std::collections::HashMap = + let raw_decls: std::collections::HashMap = de::Deserialize::deserialize(deserializer)?; - let decls = decls - .into_iter() - .map(|(name, expr)| { - expr.parse::().map(|expr| CallDecl { - label: name, - expr, - readonly: (), - }) - }) - .collect::>() - .map(|decls| Arc::new(decls)) - .map_err(de::Error::custom)?; - Ok(CallDecls { - decls, + Ok(UnresolvedCallDecls { + raw_decls: Arc::new(raw_decls), readonly: (), }) } @@ -417,60 +836,139 @@ impl CallExpr { Ok(()) } -} -/// Parse expressions of the form `Contract[address].function(arg1, arg2, -/// ...)` where the `address` and the args are either `event.address` or -/// `event.params.`. -/// -/// 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 { - lazy_static! { - static ref RE: Regex = Regex::new( - r"(?x) - (?P[a-zA-Z0-9_]+)\[ - (?P
[^]]+)\] - \. - (?P[a-zA-Z0-9_]+)\( - (?P[^)]*) - \)" + + /// Parse a call expression with ABI context to resolve field names at parse time + pub fn parse( + s: &str, + abi_json: &AbiJson, + event_signature: Option<&str>, + spec_version: &semver::Version, + ) -> Result { + // Parse the expression manually to inject ABI context for field name resolution + // Format: Contract[address].function(arg1, arg2, ...) + + // Find the contract name and opening bracket + let bracket_pos = s.find('[').ok_or_else(|| { + anyhow!( + "Invalid call expression '{}': missing '[' after contract name", + s + ) + })?; + let abi = s[..bracket_pos].trim(); + + if abi.is_empty() { + return Err(anyhow!( + "Invalid call expression '{}': missing contract name before '['", + s + )); + } + + // Find the closing bracket and extract the address part + let bracket_end = s.find(']').ok_or_else(|| { + anyhow!( + "Invalid call expression '{}': missing ']' to close address", + s ) - .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 = x - .name("args") - .unwrap() - .as_str() - .split(',') - .filter(|s| !s.is_empty()) - .map(|s| s.trim().parse::()) - .collect::>()?; - - let call_expr = CallExpr { - abi, + })?; + let address_str = &s[bracket_pos + 1..bracket_end]; + + if address_str.is_empty() { + return Err(anyhow!( + "Invalid call expression '{}': empty address in '{}[{}]'", + s, + abi, + address_str + )); + } + + // Parse the address with ABI context + let address = CallArg::parse_with_abi(address_str, abi_json, event_signature, spec_version) + .with_context(|| { + format!( + "Failed to parse address '{}' in call expression '{}'", + address_str, s + ) + })?; + + // Find the function name and arguments + let dot_pos = s[bracket_end..].find('.').ok_or_else(|| { + anyhow!( + "Invalid call expression '{}': missing '.' after address '{}[{}]'", + s, + abi, + address_str + ) + })?; + let func_start = bracket_end + dot_pos + 1; + + let paren_pos = s[func_start..].find('(').ok_or_else(|| { + anyhow!( + "Invalid call expression '{}': missing '(' to start function arguments", + s + ) + })?; + let func = &s[func_start..func_start + paren_pos]; + + if func.is_empty() { + return Err(anyhow!( + "Invalid call expression '{}': missing function name after '{}[{}].'", + s, + abi, + address_str + )); + } + + // Find the closing parenthesis and extract arguments + let paren_end = s.rfind(')').ok_or_else(|| { + anyhow!( + "Invalid call expression '{}': missing ')' to close function arguments", + s + ) + })?; + let args_str = &s[func_start + paren_pos + 1..paren_end]; + + // Parse arguments with ABI context + let mut args = Vec::new(); + if !args_str.trim().is_empty() { + for (i, arg_str) in args_str.split(',').enumerate() { + let arg_str = arg_str.trim(); + let arg = CallArg::parse_with_abi(arg_str, abi_json, event_signature, spec_version) + .with_context(|| { + format!( + "Failed to parse argument {} '{}' in call expression '{}'", + i + 1, + arg_str, + s + ) + })?; + args.push(arg); + } + } + + let expr = CallExpr { + abi: Word::from(abi), address, - func, + func: Word::from(func), args, readonly: (), }; - // Validate the arguments after constructing the CallExpr - call_expr.validate_args()?; - - Ok(call_expr) + expr.validate_args().with_context(|| { + format!( + "Invalid call expression '{}': argument validation failed", + s + ) + })?; + Ok(expr) } } - +/// Parse expressions of the form `Contract[address].function(arg1, arg2, +/// ...)` where the `address` and the args are either `event.address` or +/// `event.params.`. +/// +/// 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 #[derive(Clone, Debug, Hash, Eq, PartialEq)] pub enum CallArg { // Hard-coded hex address @@ -481,10 +979,60 @@ pub enum CallArg { Subgraph(SubgraphArg), } +/// Information about struct field mappings extracted from ABI JSON components +#[derive(Clone, Debug, PartialEq)] +pub struct StructFieldInfo { + /// Original parameter name from the event + pub param_name: String, + /// Mapping from field names to their indices in the tuple + pub field_mappings: HashMap, + /// The ethabi ParamType for type validation + pub param_type: ParamType, +} + +impl StructFieldInfo { + /// Create a new StructFieldInfo from ABI JSON components + pub fn from_components( + param_name: String, + param_type: ParamType, + components: &serde_json::Value, + ) -> Result { + let mut field_mappings = HashMap::new(); + + if let Some(components_array) = components.as_array() { + for (index, component) in components_array.iter().enumerate() { + if let Some(field_name) = component.get("name").and_then(|n| n.as_str()) { + field_mappings.insert(field_name.to_string(), index); + } + } + } + + Ok(StructFieldInfo { + param_name, + field_mappings, + param_type, + }) + } + + /// Resolve a field name to its tuple index + pub fn resolve_field_name(&self, field_name: &str) -> Option { + self.field_mappings.get(field_name).copied() + } + + /// Get all available field names + pub fn get_field_names(&self) -> Vec { + let mut names: Vec<_> = self.field_mappings.keys().cloned().collect(); + names.sort(); + names + } +} + #[derive(Clone, Debug, Hash, Eq, PartialEq)] pub enum EthereumArg { Address, Param(Word), + /// Struct field access with numeric indices (field names resolved at parse time) + StructField(Word, Vec), } #[derive(Clone, Debug, Hash, Eq, PartialEq)] @@ -497,21 +1045,119 @@ lazy_static! { 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 { +impl CallArg { + /// Parse a call argument with ABI context to resolve field names at parse time + pub fn parse_with_abi( + s: &str, + abi_json: &AbiJson, + event_signature: Option<&str>, + spec_version: &semver::Version, + ) -> Result { + // Handle hex addresses first if ADDR_RE.is_match(s) { if let Ok(parsed_address) = Address::from_str(s) { return Ok(CallArg::HexAddress(parsed_address)); } } + // Context validation + let starts_with_event = s.starts_with("event."); + let starts_with_entity = s.starts_with("entity."); + + match event_signature { + None => { + // In entity handler context: forbid event.* expressions + if starts_with_event { + return Err(anyhow!( + "'event.*' expressions not allowed in entity handler context" + )); + } + } + Some(_) => { + // In event handler context: require event.* expressions (or hex addresses) + if starts_with_entity { + return Err(anyhow!( + "'entity.*' expressions not allowed in event handler context" + )); + } + if !starts_with_event && !ADDR_RE.is_match(s) { + return Err(anyhow!( + "In event handler context, only 'event.*' expressions and hex addresses are allowed" + )); + } + } + } + let mut parts = s.split('.'); match (parts.next(), parts.next(), parts.next()) { (Some("event"), Some("address"), None) => Ok(CallArg::Ethereum(EthereumArg::Address)), (Some("event"), Some("params"), Some(param)) => { - Ok(CallArg::Ethereum(EthereumArg::Param(Word::from(param)))) + // Check if there are any additional parts for struct field access + let remaining_parts: Vec<&str> = parts.collect(); + if remaining_parts.is_empty() { + // Simple parameter access: event.params.foo + Ok(CallArg::Ethereum(EthereumArg::Param(Word::from(param)))) + } else { + // Struct field access: event.params.foo.bar.0.baz... + // Validate spec version before allowing any struct field access + if spec_version < &SPEC_VERSION_1_4_0 { + return Err(anyhow!( + "Struct field access 'event.params.{}.*' in declarative calls is only supported for specVersion >= 1.4.0, current version is {}. Event: '{}'", + param, + spec_version, + event_signature.unwrap_or("unknown") + )); + } + + // Resolve field path - supports both numeric and named fields + let field_indices = if let Some(signature) = event_signature { + // Build field path: [param, field1, field2, ...] + let mut field_path = vec![param]; + field_path.extend(remaining_parts.clone()); + + let resolved_indices = abi_json + .get_nested_struct_field_info(signature, &field_path) + .with_context(|| { + format!( + "Failed to resolve nested field path for event '{}', path '{}'", + signature, + field_path.join(".") + ) + })?; + + match resolved_indices { + Some(indices) => indices, + None => { + return Err(anyhow!( + "Cannot resolve field path 'event.params.{}' for event '{}'", + field_path.join("."), + signature + )); + } + } + } else { + // No ABI context - only allow numeric indices + let all_numeric = remaining_parts + .iter() + .all(|part| part.parse::().is_ok()); + if !all_numeric { + return Err(anyhow!( + "Field access 'event.params.{}.{}' requires event signature context for named field resolution", + param, + remaining_parts.join(".") + )); + } + remaining_parts + .into_iter() + .map(|part| part.parse::()) + .collect::, _>>() + .with_context(|| format!("Failed to parse numeric field indices"))? + }; + Ok(CallArg::Ethereum(EthereumArg::StructField( + Word::from(param), + field_indices, + ))) + } } (Some("entity"), Some(param), None) => Ok(CallArg::Subgraph(SubgraphArg::EntityParam( Word::from(param), @@ -541,11 +1187,20 @@ impl DeclaredCall { call_decls: &CallDecls, log: &Log, params: &[LogParam], + ) -> Result, anyhow::Error> { + Self::from_log_trigger_with_event(mapping, call_decls, log, params) + } + + pub fn from_log_trigger_with_event( + mapping: &dyn FindMappingABI, + call_decls: &CallDecls, + log: &Log, + params: &[LogParam], ) -> Result, anyhow::Error> { Self::create_calls(mapping, call_decls, |decl, _| { Ok(( - decl.address_for_log(log, params)?, - decl.args_for_log(log, params)?, + decl.address_for_log_with_abi(log, params)?, + decl.args_for_log_with_abi(log, params)?, )) }) } @@ -625,13 +1280,188 @@ pub struct ContractCall { #[cfg(test)] mod tests { + use crate::data::subgraph::SPEC_VERSION_1_3_0; + use super::*; + const EV_TRANSFER: Option<&str> = Some("Transfer(address,tuple)"); + const EV_COMPLEX_ASSET: Option<&str> = + Some("ComplexAssetCreated(((address,uint256,bool),string,uint256[]),uint256)"); + + /// Test helper for parsing CallExpr expressions with predefined ABI and + /// event context. + /// + /// This struct simplifies testing by providing a fluent API for parsing + /// call expressions with the test ABI (from + /// `create_test_mapping_abi()`). It handles three main contexts: + /// - Event handler context with Transfer event (default) + /// - Event handler context with ComplexAssetCreated event + /// (`for_complex_asset()`) + /// - Entity handler context with no event (`for_subgraph()`) + /// + /// # Examples + /// ```ignore + /// let parser = ExprParser::new(); + /// // Parse and expect success + /// let expr = parser.ok("Contract[event.params.asset.addr].test()"); + /// + /// // Parse and expect error, get error message + /// let error_msg = parser.err("Contract[invalid].test()"); + /// + /// // Test with different spec version + /// let result = parser.parse_with_version(expr, &old_version); + /// + /// // Test entity handler context + /// let entity_parser = ExprParser::new().for_subgraph(); + /// let expr = entity_parser.ok("Contract[entity.addr].test()"); + /// ``` + struct ExprParser { + abi: super::AbiJson, + event: Option, + } + + impl ExprParser { + /// Creates a new parser with the test ABI and Transfer event context + fn new() -> Self { + let abi = create_test_mapping_abi(); + Self { + abi, + event: EV_TRANSFER.map(|s| s.to_string()), + } + } + + /// Switches to entity handler context (no event signature) + fn for_subgraph(mut self) -> Self { + self.event = None; + self + } + + /// Switches to ComplexAssetCreated event context for testing nested + /// structs + fn for_complex_asset(mut self) -> Self { + self.event = EV_COMPLEX_ASSET.map(|s| s.to_string()); + self + } + + /// Parses an expression using the default spec version (1.4.0) + fn parse(&self, expression: &str) -> Result { + self.parse_with_version(expression, &SPEC_VERSION_1_4_0) + } + + /// Parses an expression with a specific spec version for testing + /// version compatibility + fn parse_with_version( + &self, + expression: &str, + spec_version: &semver::Version, + ) -> Result { + CallExpr::parse(expression, &self.abi, self.event.as_deref(), spec_version) + } + + /// Parses an expression and panics if it fails, returning the + /// parsed CallExpr. Use this when the expression is expected to + /// parse successfully. + #[track_caller] + fn ok(&self, expression: &str) -> CallExpr { + let result = self.parse(expression); + assert!( + result.is_ok(), + "Expression '{}' should have parsed successfully: {:#}", + expression, + result.unwrap_err() + ); + result.unwrap() + } + + /// Parses an expression and panics if it succeeds, returning the + /// error message. Use this when testing error cases and you want to + /// verify the error message. + #[track_caller] + fn err(&self, expression: &str) -> String { + match self.parse(expression) { + Ok(expr) => { + panic!( + "Expression '{}' should have failed to parse but yielded {:#?}", + expression, expr + ); + } + Err(e) => { + format!("{:#}", e) + } + } + } + } + + /// Test helper for parsing CallArg expressions with the test ABI. + /// + /// This struct is specifically for testing argument parsing (e.g., + /// `event.params.asset.addr`) as opposed to full call expressions. It + /// uses the same test ABI as ExprParser. + /// + /// # Examples + /// ```ignore + /// let parser = ArgParser::new(); + /// // Parse an event parameter argument + /// let arg = parser.ok("event.params.asset.addr", Some("Transfer(address,tuple)")); + /// + /// // Test entity context argument + /// let arg = parser.ok("entity.contractAddress", None); + /// + /// // Test error cases + /// let error = parser.err("invalid.arg", Some("Transfer(address,tuple)")); + /// ``` + struct ArgParser { + abi: super::AbiJson, + } + + impl ArgParser { + /// Creates a new argument parser with the test ABI + fn new() -> Self { + let abi = create_test_mapping_abi(); + Self { abi } + } + + /// Parses a call argument with optional event signature context + fn parse(&self, expression: &str, event_signature: Option<&str>) -> Result { + CallArg::parse_with_abi(expression, &self.abi, event_signature, &SPEC_VERSION_1_4_0) + } + + /// Parses an argument and panics if it fails, returning the parsed + /// CallArg. Use this when the argument is expected to parse + /// successfully. + fn ok(&self, expression: &str, event_signature: Option<&str>) -> CallArg { + let result = self.parse(expression, event_signature); + assert!( + result.is_ok(), + "Expression '{}' should have parsed successfully: {}", + expression, + result.unwrap_err() + ); + result.unwrap() + } + + /// Parses an argument and panics if it succeeds, returning the + /// error message. Use this when testing error cases and you want to + /// verify the error message. + fn err(&self, expression: &str, event_signature: Option<&str>) -> String { + match self.parse(expression, event_signature) { + Ok(arg) => { + panic!( + "Expression '{}' should have failed to parse but yielded {:#?}", + expression, arg + ); + } + Err(e) => { + format!("{:#}", e) + } + } + } + } + #[test] fn test_ethereum_call_expr() { - let expr: CallExpr = "ERC20[event.address].balanceOf(event.params.token)" - .parse() - .unwrap(); + let parser = ExprParser::new(); + let expr: CallExpr = parser.ok("ERC20[event.address].balanceOf(event.params.token)"); assert_eq!(expr.abi, "ERC20"); assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address)); assert_eq!(expr.func, "balanceOf"); @@ -641,9 +1471,7 @@ mod tests { ); let expr: CallExpr = - "Pool[event.params.pool].fees(event.params.token0, event.params.token1)" - .parse() - .unwrap(); + parser.ok("Pool[event.params.pool].fees(event.params.token0, event.params.token1)"); assert_eq!(expr.abi, "Pool"); assert_eq!( expr.address, @@ -661,7 +1489,9 @@ mod tests { #[test] fn test_subgraph_call_expr() { - let expr: CallExpr = "Token[entity.id].symbol()".parse().unwrap(); + let parser = ExprParser::new().for_subgraph(); + + let expr: CallExpr = parser.ok("Token[entity.id].symbol()"); assert_eq!(expr.abi, "Token"); assert_eq!( expr.address, @@ -670,9 +1500,7 @@ mod tests { assert_eq!(expr.func, "symbol"); assert_eq!(expr.args, vec![]); - let expr: CallExpr = "Pair[entity.pair].getReserves(entity.token0)" - .parse() - .unwrap(); + let expr: CallExpr = parser.ok("Pair[entity.pair].getReserves(entity.token0)"); assert_eq!(expr.abi, "Pair"); assert_eq!( expr.address, @@ -687,20 +1515,23 @@ mod tests { #[test] fn test_hex_address_call_expr() { + let parser = ExprParser::new(); + let addr = "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"; let hex_address = CallArg::HexAddress(web3::types::H160::from_str(addr).unwrap()); // Test HexAddress in address position - let expr: CallExpr = format!("Pool[{}].growth()", addr).parse().unwrap(); + let expr: CallExpr = parser.ok(&format!("Pool[{}].growth()", addr)); assert_eq!(expr.abi, "Pool"); assert_eq!(expr.address, hex_address.clone()); assert_eq!(expr.func, "growth"); assert_eq!(expr.args, vec![]); // Test HexAddress in argument position - let expr: CallExpr = format!("Pool[event.address].approve({}, event.params.amount)", addr) - .parse() - .unwrap(); + let expr: CallExpr = parser.ok(&format!( + "Pool[event.address].approve({}, event.params.amount)", + addr + )); assert_eq!(expr.abi, "Pool"); assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address)); assert_eq!(expr.func, "approve"); @@ -710,42 +1541,591 @@ mod tests { #[test] fn test_invalid_call_args() { + let parser = ArgParser::new(); // Invalid hex address - assert!("Pool[0xinvalid].test()".parse::().is_err()); + parser.err("Pool[0xinvalid].test()", EV_TRANSFER); // Invalid event path - assert!("Pool[event.invalid].test()".parse::().is_err()); + parser.err("Pool[event.invalid].test()", EV_TRANSFER); // Invalid entity path - assert!("Pool[entity].test()".parse::().is_err()); + parser.err("Pool[entity].test()", EV_TRANSFER); // Empty address - assert!("Pool[].test()".parse::().is_err()); + parser.err("Pool[].test()", EV_TRANSFER); // Invalid parameter format - assert!("Pool[event.params].test()".parse::().is_err()); + parser.err("Pool[event.params].test()", EV_TRANSFER); } #[test] - fn test_from_str() { + fn test_simple_args() { + let parser = ArgParser::new(); + // Test valid hex address let addr = "0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF"; - let arg = CallArg::from_str(addr).unwrap(); + let arg = parser.ok(addr, EV_TRANSFER); assert!(matches!(arg, CallArg::HexAddress(_))); // Test Ethereum Address - let arg = CallArg::from_str("event.address").unwrap(); + let arg = parser.ok("event.address", EV_TRANSFER); assert!(matches!(arg, CallArg::Ethereum(EthereumArg::Address))); // Test Ethereum Param - let arg = CallArg::from_str("event.params.token").unwrap(); + let arg = parser.ok("event.params.token", EV_TRANSFER); assert!(matches!(arg, CallArg::Ethereum(EthereumArg::Param(_)))); // Test Subgraph EntityParam - let arg = CallArg::from_str("entity.token").unwrap(); + let arg = parser.ok("entity.token", None); assert!(matches!( arg, CallArg::Subgraph(SubgraphArg::EntityParam(_)) )); } + + #[test] + fn test_struct_field_access_functions() { + use ethabi::Token; + + let parser = ExprParser::new(); + + let tuple_fields = vec![ + Token::Uint(ethabi::Uint::from(8u8)), // index 0: uint8 + Token::Address([1u8; 20].into()), // index 1: address + Token::Uint(ethabi::Uint::from(1000u64)), // index 2: uint256 + ]; + + // Test extract_struct_field with numeric indices + let struct_token = Token::Tuple(tuple_fields.clone()); + + // Test accessing index 0 (uint8) + let result = + CallDecl::extract_nested_struct_field(&struct_token, &[0], "testCall").unwrap(); + assert_eq!(result, tuple_fields[0]); + + // Test accessing index 1 (address) + let result = + CallDecl::extract_nested_struct_field(&struct_token, &[1], "testCall").unwrap(); + assert_eq!(result, tuple_fields[1]); + + // Test accessing index 2 (uint256) + let result = + CallDecl::extract_nested_struct_field(&struct_token, &[2], "testCall").unwrap(); + assert_eq!(result, tuple_fields[2]); + + // Test that it works in a declarative call context + let expr: CallExpr = parser.ok("ERC20[event.params.asset.1].name()"); + assert_eq!(expr.abi, "ERC20"); + assert_eq!( + expr.address, + CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1])) + ); + assert_eq!(expr.func, "name"); + assert_eq!(expr.args, vec![]); + } + + #[test] + fn test_invalid_struct_field_parsing() { + let parser = ArgParser::new(); + // Test invalid patterns + parser.err("event.params", EV_TRANSFER); + parser.err("event.invalid.param.field", EV_TRANSFER); + } + + #[test] + fn test_declarative_call_error_context() { + use crate::prelude::web3::types::{Log, H160, H256}; + use ethabi::{LogParam, Token}; + + let parser = ExprParser::new(); + + // Create a test call declaration + let call_decl = CallDecl { + label: "myTokenCall".to_string(), + expr: parser.ok("ERC20[event.params.asset.1].name()"), + readonly: (), + }; + + // Test scenario 1: Unknown parameter + let log = Log { + address: H160::zero(), + topics: vec![], + data: vec![].into(), + block_hash: Some(H256::zero()), + block_number: Some(1.into()), + transaction_hash: Some(H256::zero()), + transaction_index: Some(0.into()), + log_index: Some(0.into()), + transaction_log_index: Some(0.into()), + log_type: None, + removed: Some(false), + }; + let params = vec![]; // Empty params - 'asset' param is missing + + let result = call_decl.address_for_log(&log, ¶ms); + assert!(result.is_err()); + let error_msg = result.unwrap_err().to_string(); + assert!(error_msg.contains("In declarative call 'myTokenCall'")); + assert!(error_msg.contains("unknown param asset")); + + // Test scenario 2: Struct field access error + let params = vec![LogParam { + name: "asset".to_string(), + value: Token::Tuple(vec![Token::Uint(ethabi::Uint::from(1u8))]), // Only 1 field, but trying to access index 1 + }]; + + let result = call_decl.address_for_log(&log, ¶ms); + assert!(result.is_err()); + let error_msg = result.unwrap_err().to_string(); + assert!(error_msg.contains("In declarative call 'myTokenCall'")); + assert!(error_msg.contains("out of bounds")); + assert!(error_msg.contains("struct has 1 fields")); + + // Test scenario 3: Non-address field access + let params = vec![LogParam { + name: "asset".to_string(), + value: Token::Tuple(vec![ + Token::Uint(ethabi::Uint::from(1u8)), + Token::Uint(ethabi::Uint::from(2u8)), // Index 1 is uint, not address + ]), + }]; + + let result = call_decl.address_for_log(&log, ¶ms); + assert!(result.is_err()); + let error_msg = result.unwrap_err().to_string(); + assert!(error_msg.contains("In declarative call 'myTokenCall'")); + assert!(error_msg.contains("nested struct field is not an address")); + + // Test scenario 4: Field index out of bounds is caught at parse time + let parser = parser.for_complex_asset(); + let error_msg = + parser.err("ERC20[event.address].transfer(event.params.complexAsset.base.3)"); + assert!(error_msg.contains("Index 3 out of bounds for struct with 3 fields")); + + // Test scenario 5: Runtime struct field extraction error - out of bounds + let expr = parser.ok("ERC20[event.address].transfer(event.params.complexAsset.base.2)"); + let call_decl_with_args = CallDecl { + label: "transferCall".to_string(), + expr, + readonly: (), + }; + + // Create a structure where base has only 2 fields instead of 3 + // The parser thinks there should be 3 fields based on ABI, but at runtime we provide only 2 + let base_struct = Token::Tuple(vec![ + Token::Address([1u8; 20].into()), // addr at index 0 + Token::Uint(ethabi::Uint::from(100u64)), // amount at index 1 + // Missing the active field at index 2! + ]); + + let params = vec![LogParam { + name: "complexAsset".to_string(), + value: Token::Tuple(vec![ + base_struct, // base with only 2 fields + Token::String("metadata".to_string()), // metadata at index 1 + Token::Array(vec![]), // values at index 2 + ]), + }]; + + let result = call_decl_with_args.args_for_log(&log, ¶ms); + assert!(result.is_err()); + let error_msg = result.unwrap_err().to_string(); + assert!(error_msg.contains("In declarative call 'transferCall'")); + assert!(error_msg.contains("out of bounds")); + assert!(error_msg.contains("struct has 2 fields")); + } + + #[test] + fn test_struct_field_extraction_comprehensive() { + use ethabi::Token; + + // Create a complex nested structure for comprehensive testing: + // struct Asset { + // uint8 kind; // index 0 + // Token token; // index 1 (nested struct) + // uint256 amount; // index 2 + // } + // struct Token { + // address addr; // index 0 + // string name; // index 1 + // } + let inner_struct = Token::Tuple(vec![ + Token::Address([0x42; 20].into()), // token.addr + Token::String("TokenName".to_string()), // token.name + ]); + + let outer_struct = Token::Tuple(vec![ + Token::Uint(ethabi::Uint::from(1u8)), // asset.kind + inner_struct, // asset.token + Token::Uint(ethabi::Uint::from(1000u64)), // asset.amount + ]); + + // Test cases: (path, expected_value, description) + let test_cases = vec![ + ( + vec![0], + Token::Uint(ethabi::Uint::from(1u8)), + "Simple field access", + ), + ( + vec![1, 0], + Token::Address([0x42; 20].into()), + "Nested field access", + ), + ( + vec![1, 1], + Token::String("TokenName".to_string()), + "Nested string field", + ), + ( + vec![2], + Token::Uint(ethabi::Uint::from(1000u64)), + "Last field access", + ), + ]; + + for (path, expected, description) in test_cases { + let result = CallDecl::extract_nested_struct_field(&outer_struct, &path, "testCall") + .unwrap_or_else(|e| panic!("Failed {}: {}", description, e)); + assert_eq!(result, expected, "Failed: {}", description); + } + + // Test error cases + let error_cases = vec![ + (vec![3], "out of bounds (struct has 3 fields)"), + (vec![1, 2], "struct has 2 fields"), + (vec![0, 0], "cannot access field on non-struct/tuple"), + ]; + + for (path, expected_error) in error_cases { + let result = CallDecl::extract_nested_struct_field(&outer_struct, &path, "testCall"); + assert!(result.is_err(), "Expected error for path: {:?}", path); + let error_msg = result.unwrap_err().to_string(); + assert!( + error_msg.contains(expected_error), + "Error message should contain '{}'. Got: {}", + expected_error, + error_msg + ); + } + } + + #[test] + fn test_abi_aware_named_field_resolution() { + let parser = ExprParser::new(); + + // Test 1: Named field resolution with ABI context + let expr = parser.ok("TestContract[event.params.asset.addr].name()"); + + assert_eq!(expr.abi, "TestContract"); + assert_eq!( + expr.address, + CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![0])) // addr -> 0 + ); + assert_eq!(expr.func, "name"); + assert_eq!(expr.args, vec![]); + + // Test 2: Mixed named and numeric access in arguments + let expr = parser.ok( + "TestContract[event.address].transfer(event.params.asset.amount, event.params.asset.1)", + ); + + assert_eq!(expr.abi, "TestContract"); + assert_eq!(expr.address, CallArg::Ethereum(EthereumArg::Address)); + assert_eq!(expr.func, "transfer"); + assert_eq!( + expr.args, + vec![ + CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1])), // amount -> 1 + CallArg::Ethereum(EthereumArg::StructField("asset".into(), vec![1])), // numeric 1 + ] + ); + } + + #[test] + fn test_abi_aware_error_handling() { + let parser = ExprParser::new(); + + // Test 1: Invalid field name provides helpful suggestions + let error_msg = parser.err("TestContract[event.params.asset.invalid].name()"); + assert!(error_msg.contains("Field 'invalid' not found")); + assert!(error_msg.contains("Available fields:")); + + // Test 2: Named field access without event context + let error_msg = parser + .for_subgraph() + .err("TestContract[event.params.asset.addr].name()"); + assert!(error_msg.contains("'event.*' expressions not allowed in entity handler context")); + } + + #[test] + fn test_parse_function_error_messages() { + const SV: &semver::Version = &SPEC_VERSION_1_4_0; + const EV: Option<&str> = Some("Test()"); + + // Create a minimal ABI for testing + let abi_json = r#"[{"anonymous": false, "inputs": [], "name": "Test", "type": "event"}]"#; + let abi_json_helper = AbiJson::new(abi_json.as_bytes()).unwrap(); + + let parse = |expr: &str| { + let result = CallExpr::parse(expr, &abi_json_helper, EV, SV); + assert!( + result.is_err(), + "Expression {} should have failed to parse", + expr + ); + result.unwrap_err().to_string() + }; + + // Test 1: Missing opening bracket + let error_msg = parse("TestContract event.address].test()"); + assert!(error_msg.contains("Invalid call expression")); + assert!(error_msg.contains("missing '[' after contract name")); + + // Test 2: Missing closing bracket + let error_msg = parse("TestContract[event.address.test()"); + assert!(error_msg.contains("missing ']' to close address")); + + // Test 3: Empty contract name + let error_msg = parse("[event.address].test()"); + assert!(error_msg.contains("missing contract name before '['")); + + // Test 4: Empty address + let error_msg = parse("TestContract[].test()"); + assert!(error_msg.contains("empty address")); + + // Test 5: Missing function name + let error_msg = parse("TestContract[event.address].()"); + assert!(error_msg.contains("missing function name")); + + // Test 6: Missing opening parenthesis + let error_msg = parse("TestContract[event.address].test"); + assert!(error_msg.contains("missing '(' to start function arguments")); + + // Test 7: Missing closing parenthesis + let error_msg = parse("TestContract[event.address].test("); + assert!(error_msg.contains("missing ')' to close function arguments")); + + // Test 8: Invalid argument should show argument position + let error_msg = parse("TestContract[event.address].test(invalid.arg)"); + assert!(error_msg.contains("Failed to parse argument 1")); + assert!(error_msg.contains("'invalid.arg'")); + } + + #[test] + fn test_call_expr_abi_context_comprehensive() { + // Comprehensive test for CallExpr parsing with ABI context + let parser = ExprParser::new().for_complex_asset(); + + // Test 1: Parse-time field name resolution + let expr = parser.ok("Contract[event.params.complexAsset.base.addr].test()"); + assert_eq!( + expr.address, + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) + ); + + // Test 2: Mixed named and numeric field access + let expr = parser.ok( + "Contract[event.address].test(event.params.complexAsset.0.1, event.params.complexAsset.base.active)" + ); + assert_eq!( + expr.args, + vec![ + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])), // base.amount + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 2])), // base.active + ] + ); + + // Test 3: Error - Invalid field name with helpful suggestions + let error_msg = parser.err("Contract[event.params.complexAsset.invalid].test()"); + assert!(error_msg.contains("Field 'invalid' not found")); + // Check that it mentions available fields (the exact format may vary) + assert!( + error_msg.contains("base") + && error_msg.contains("metadata") + && error_msg.contains("values") + ); + + // Test 4: Error - Accessing nested field on non-struct + let error_msg = parser.err("Contract[event.params.complexAsset.metadata.something].test()"); + assert!(error_msg.contains("is not a struct")); + + // Test 5: Error - Out of bounds numeric access + let error_msg = parser.err("Contract[event.params.complexAsset.3].test()"); + assert!(error_msg.contains("out of bounds")); + + // Test 6: Deep nesting with mixed access + let expr = parser.ok( + "Contract[event.params.complexAsset.base.0].test(event.params.complexAsset.0.amount)", + ); + assert_eq!( + expr.address, + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // base.addr + ); + assert_eq!( + expr.args, + vec![ + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])) // base.amount + ] + ); + + // Test 7: Version check - struct field access requires v1.4.0+ + let result = parser.parse_with_version( + "Contract[event.params.complexAsset.base.addr].test()", + &SPEC_VERSION_1_3_0, + ); + assert!(result.is_err()); + let error_msg = format!("{:#}", result.unwrap_err()); + assert!(error_msg.contains("only supported for specVersion >= 1.4.0")); + + // Test 8: Entity handler context - no event.* expressions allowed + let entity_parser = ExprParser::new().for_subgraph(); + let error_msg = entity_parser.err("Contract[event.params.something].test()"); + assert!(error_msg.contains("'event.*' expressions not allowed in entity handler context")); + + // Test 9: Successful entity handler expression + let expr = entity_parser.ok("Contract[entity.contractAddress].test(entity.amount)"); + assert!(matches!(expr.address, CallArg::Subgraph(_))); + assert!(matches!(expr.args[0], CallArg::Subgraph(_))); + } + + #[test] + fn complex_asset() { + let parser = ExprParser::new().for_complex_asset(); + + // Test 1: All named field access: event.params.complexAsset.base.addr + let expr = + parser.ok("Contract[event.address].getMetadata(event.params.complexAsset.base.addr)"); + assert_eq!( + expr.args[0], + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // base=0, addr=0 + ); + + // Test 2: All numeric field access: event.params.complexAsset.0.0 + let expr = parser.ok("Contract[event.address].getMetadata(event.params.complexAsset.0.0)"); + assert_eq!( + expr.args[0], + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) + ); + + // Test 3: Mixed access - numeric then named: event.params.complexAsset.0.addr + let expr = parser.ok("Contract[event.address].transfer(event.params.complexAsset.0.addr)"); + assert_eq!( + expr.args[0], + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 0])) // 0=base, addr=0 + ); + + // Test 4: Mixed access - named then numeric: event.params.complexAsset.base.1 + let expr = + parser.ok("Contract[event.address].updateAmount(event.params.complexAsset.base.1)"); + assert_eq!( + expr.args[0], + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![0, 1])) // base=0, 1=amount + ); + + // Test 5: Access non-nested field by name: event.params.complexAsset.metadata + let expr = + parser.ok("Contract[event.address].setMetadata(event.params.complexAsset.metadata)"); + assert_eq!( + expr.args[0], + CallArg::Ethereum(EthereumArg::StructField("complexAsset".into(), vec![1])) // metadata=1 + ); + + // Test 6: Error case - invalid field name + let error_msg = + parser.err("Contract[event.address].test(event.params.complexAsset.invalid)"); + assert!(error_msg.contains("Field 'invalid' not found")); + + // Test 7: Error case - accessing nested field on non-tuple + let error_msg = parser + .err("Contract[event.address].test(event.params.complexAsset.metadata.something)"); + assert!(error_msg.contains("is not a struct")); + } + + // Helper function to create consistent test ABI + fn create_test_mapping_abi() -> AbiJson { + const ABI_JSON: &str = r#"[ + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "from", + "type": "address" + }, + { + "indexed": false, + "name": "asset", + "type": "tuple", + "components": [ + { + "name": "addr", + "type": "address" + }, + { + "name": "amount", + "type": "uint256" + }, + { + "name": "active", + "type": "bool" + } + ] + } + ], + "name": "Transfer", + "type": "event" + }, + { + "type": "event", + "name": "ComplexAssetCreated", + "inputs": [ + { + "name": "complexAsset", + "type": "tuple", + "indexed": false, + "internalType": "struct DeclaredCallsContract.ComplexAsset", + "components": [ + { + "name": "base", + "type": "tuple", + "internalType": "struct DeclaredCallsContract.Asset", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "active", + "type": "bool", + "internalType": "bool" + } + ] + }, + { + "name": "metadata", + "type": "string", + "internalType": "string" + }, + { + "name": "values", + "type": "uint256[]", + "internalType": "uint256[]" + } + ] + } + ] + } + ]"#; + + let abi_json_helper = AbiJson::new(ABI_JSON.as_bytes()).unwrap(); + + abi_json_helper + } } diff --git a/graph/src/data_source/mod.rs b/graph/src/data_source/mod.rs index 4c56e99ea9b..51abe638b42 100644 --- a/graph/src/data_source/mod.rs +++ b/graph/src/data_source/mod.rs @@ -332,14 +332,15 @@ impl UnresolvedDataSource { resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result, anyhow::Error> { match self { Self::Onchain(unresolved) => unresolved - .resolve(resolver, logger, manifest_idx) + .resolve(resolver, logger, manifest_idx, spec_version) .await .map(DataSource::Onchain), Self::Subgraph(unresolved) => unresolved - .resolve::(resolver, logger, manifest_idx) + .resolve::(resolver, logger, manifest_idx, spec_version) .await .map(DataSource::Subgraph), Self::Offchain(_unresolved) => { @@ -462,10 +463,11 @@ impl UnresolvedDataSourceTemplate { schema: &InputSchema, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result, Error> { match self { Self::Onchain(ds) => ds - .resolve(resolver, logger, manifest_idx) + .resolve(resolver, logger, manifest_idx, spec_version) .await .map(|ti| DataSourceTemplate::Onchain(ti)), Self::Offchain(ds) => ds @@ -473,7 +475,7 @@ impl UnresolvedDataSourceTemplate { .await .map(DataSourceTemplate::Offchain), Self::Subgraph(ds) => ds - .resolve(resolver, logger, manifest_idx) + .resolve(resolver, logger, manifest_idx, spec_version) .await .map(DataSourceTemplate::Subgraph), } diff --git a/graph/src/data_source/subgraph.rs b/graph/src/data_source/subgraph.rs index b5a04363093..cd728aa6a43 100644 --- a/graph/src/data_source/subgraph.rs +++ b/graph/src/data_source/subgraph.rs @@ -20,7 +20,9 @@ use slog::{info, Logger}; use std::{fmt, sync::Arc}; use super::{ - common::{CallDecls, FindMappingABI, MappingABI, UnresolvedMappingABI}, + common::{ + AbiJson, CallDecls, FindMappingABI, MappingABI, UnresolvedCallDecls, UnresolvedMappingABI, + }, DataSourceTemplateInfo, TriggerWithHandler, }; @@ -178,11 +180,34 @@ impl FindMappingABI for Mapping { } } -#[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)] -pub struct EntityHandler { +#[derive(Clone, Debug, Eq, PartialEq, Deserialize)] +pub struct UnresolvedEntityHandler { pub handler: String, pub entity: String, #[serde(default)] + pub calls: UnresolvedCallDecls, +} + +impl UnresolvedEntityHandler { + pub fn resolve( + self, + abi_json: &AbiJson, + spec_version: &semver::Version, + ) -> Result { + let resolved_calls = self.calls.resolve(abi_json, None, spec_version)?; + + Ok(EntityHandler { + handler: self.handler, + entity: self.entity, + calls: resolved_calls, + }) + } +} + +#[derive(Clone, Debug, Hash, Eq, PartialEq)] +pub struct EntityHandler { + pub handler: String, + pub entity: String, pub calls: CallDecls, } @@ -204,13 +229,13 @@ pub struct UnresolvedSource { start_block: BlockNumber, } -#[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)] +#[derive(Clone, Debug, Default, Eq, PartialEq, Deserialize)] #[serde(rename_all = "camelCase")] pub struct UnresolvedMapping { pub api_version: String, pub language: String, pub file: Link, - pub handlers: Vec, + pub handlers: Vec, pub abis: Option>, pub entities: Vec, } @@ -349,6 +374,7 @@ impl UnresolvedDataSource { resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result { info!(logger, "Resolve subgraph data source"; "name" => &self.name, @@ -409,7 +435,7 @@ impl UnresolvedDataSource { name: self.name, network: self.network, source, - mapping: self.mapping.resolve(resolver, logger).await?, + mapping: self.mapping.resolve(resolver, logger, spec_version).await?, context: Arc::new(self.context), creation_block: None, }) @@ -421,6 +447,7 @@ impl UnresolvedMapping { self, resolver: &Arc, logger: &Logger, + spec_version: &semver::Version, ) -> Result { info!(logger, "Resolve subgraph ds mapping"; "link" => &self.file.link); @@ -433,7 +460,7 @@ impl UnresolvedMapping { let logger = logger.clone(); async move { let resolved_abi = unresolved_abi.resolve(&resolver, &logger).await?; - Ok::<_, Error>(Arc::new(resolved_abi)) + Ok::<_, Error>(resolved_abi) } }) .collect::>() @@ -443,12 +470,46 @@ impl UnresolvedMapping { None => Vec::new(), }; + // Parse API version for spec version validation + let api_version = semver::Version::parse(&self.api_version)?; + + // Resolve handlers with ABI context + let resolved_handlers = if abis.is_empty() { + // If no ABIs are available, just pass through (for backward compatibility) + self.handlers + .into_iter() + .map(|handler| { + if handler.calls.is_empty() { + Ok(EntityHandler { + handler: handler.handler, + entity: handler.entity, + calls: CallDecls::default(), + }) + } else { + Err(anyhow::Error::msg( + "Cannot resolve declarative calls without ABI", + )) + } + }) + .collect::, _>>()? + } else { + // Resolve using the first available ABI (subgraph data sources typically have one ABI) + let (_, abi_json) = &abis[0]; + self.handlers + .into_iter() + .map(|handler| handler.resolve(abi_json, spec_version)) + .collect::, _>>()? + }; + + // Extract just the MappingABIs for the final Mapping struct + let mapping_abis = abis.into_iter().map(|(abi, _)| Arc::new(abi)).collect(); + Ok(Mapping { language: self.language, - api_version: semver::Version::parse(&self.api_version)?, + api_version, entities: self.entities, - handlers: self.handlers, - abis, + handlers: resolved_handlers, + abis: mapping_abis, runtime: Arc::new(resolver.cat(logger, &self.file).await?), link: self.file, }) @@ -498,12 +559,13 @@ impl UnresolvedDataSourceTemplate { resolver: &Arc, logger: &Logger, manifest_idx: u32, + spec_version: &semver::Version, ) -> Result { let kind = self.kind; let mapping = self .mapping - .resolve(resolver, logger) + .resolve(resolver, logger, spec_version) .await .with_context(|| format!("failed to resolve data source template {}", self.name))?; diff --git a/graph/src/env/mod.rs b/graph/src/env/mod.rs index 42274946edb..802b304db1f 100644 --- a/graph/src/env/mod.rs +++ b/graph/src/env/mod.rs @@ -442,7 +442,7 @@ struct Inner { default = "false" )] allow_non_deterministic_fulltext_search: EnvVarBoolean, - #[envconfig(from = "GRAPH_MAX_SPEC_VERSION", default = "1.3.0")] + #[envconfig(from = "GRAPH_MAX_SPEC_VERSION", default = "1.4.0")] max_spec_version: Version, #[envconfig(from = "GRAPH_LOAD_WINDOW_SIZE", default = "300")] load_window_size_in_secs: u64, diff --git a/justfile b/justfile index 94f3c867bf7..ed12ad84356 100644 --- a/justfile +++ b/justfile @@ -83,3 +83,24 @@ test-integration *EXTRA_FLAGS: # Clean workspace (cargo clean) clean: cargo clean + +compile-contracts: + #!/usr/bin/env bash + set -e # Exit on error + + if ! command -v "forge" &> /dev/null; then + echo "Error: forge must be on your path" + exit 1 + fi + + cd tests/contracts + + forge build + + mkdir -p abis + for c in src/*.sol + do + contract=$(basename $c .sol) + echo $contract + forge inspect --json "$contract" abi > "abis/$contract.json" + done diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 9bc3c730543..9276137fd13 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -26,6 +26,24 @@ importers: specifier: 0.34.0 version: 0.34.0 + tests/integration-tests/declared-calls-basic: + devDependencies: + '@graphprotocol/graph-cli': + specifier: 0.97.1 + version: 0.97.1(@types/node@24.3.0)(bufferutil@4.0.9)(typescript@5.9.2)(utf-8-validate@5.0.10)(zod@3.25.76) + '@graphprotocol/graph-ts': + specifier: 0.33.0 + version: 0.33.0 + + tests/integration-tests/declared-calls-struct-fields: + devDependencies: + '@graphprotocol/graph-cli': + specifier: 0.97.1 + version: 0.97.1(@types/node@24.3.0)(bufferutil@4.0.9)(typescript@5.9.2)(utf-8-validate@5.0.10)(zod@3.25.76) + '@graphprotocol/graph-ts': + specifier: 0.33.0 + version: 0.33.0 + tests/integration-tests/ethereum-api-tests: devDependencies: '@graphprotocol/graph-cli': @@ -426,12 +444,20 @@ packages: engines: {node: '>=20.18.1'} hasBin: true + '@graphprotocol/graph-cli@0.97.1': + resolution: {integrity: sha512-j5dc2Tl694jMZmVQu8SSl5Yt3VURiBPgglQEpx30aW6UJ89eLR/x46Nn7S6eflV69fmB5IHAuAACnuTzo8MD0Q==} + engines: {node: '>=20.18.1'} + hasBin: true + '@graphprotocol/graph-ts@0.30.0': resolution: {integrity: sha512-h5tJqlsZXglGYM0PcBsBOqof4PT0Fr4Z3QBTYN/IjMF3VvRX2A8/bdpqaAnva+2N0uAfXXwRcwcOcW5O35yzXw==} '@graphprotocol/graph-ts@0.31.0': resolution: {integrity: sha512-xreRVM6ho2BtolyOh2flDkNoGZximybnzUnF53zJVp0+Ed0KnAlO1/KOCUYw06euVI9tk0c9nA2Z/D5SIQV2Rg==} + '@graphprotocol/graph-ts@0.33.0': + resolution: {integrity: sha512-HBUVblHUdjQZ/MEjjYPzVgmh+SiuF9VV0D8KubYfFAtzkqpVJlvdyk+RZTAJUiu8hpyYy0EVIcAnLEPtKlwMGQ==} + '@graphprotocol/graph-ts@0.34.0': resolution: {integrity: sha512-gnhjai65AV4YMYe9QHGz+HP/jdzI54z/nOfEXZFfh6m987EP2iy3ycLXrTi+ahcogHH7vtoWFdXbUzZbE8bCAg==} @@ -684,6 +710,10 @@ packages: resolution: {integrity: sha512-jHww7lIqyifamynDSjDNNjNOwFTQdKYeOSYaxUaoWhqXnRwacZ+pfUN4Y0L9lqSN4MQtlWM9mwnBD7FvlT9kPw==} engines: {node: '>=18.0.0'} + '@oclif/core@4.3.0': + resolution: {integrity: sha512-lIzHY+JMP6evrS5E/sGijNnwrCoNtGy8703jWXcMuPOYKiFhWoAqnIm1BGgoRgmxczkbSfRsHUL/lwsSgh74Lw==} + engines: {node: '>=18.0.0'} + '@oclif/core@4.5.2': resolution: {integrity: sha512-eQcKyrEcDYeZJKu4vUWiu0ii/1Gfev6GF4FsLSgNez5/+aQyAUCjg3ZWlurf491WiYZTXCWyKAxyPWk8DKv2MA==} engines: {node: '>=18.0.0'} @@ -1190,6 +1220,10 @@ packages: resolution: {integrity: sha512-n8enUVCED/KVRQlab1hr3MVpcVMvxtZjmEa956u+4YijlmQED223XMSYj2tLuKvr4jcCTzNNMpQDUer72MMmzA==} engines: {node: '>= 14.16.0'} + chokidar@4.0.3: + resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==} + engines: {node: '>= 14.16.0'} + chownr@1.1.4: resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} @@ -1393,6 +1427,10 @@ packages: resolution: {integrity: sha512-VrkQJNafPQ5d6bGULW0P6KqcxSkv3ZU5Wn2wQA19oB71o7+55vQ9ogFe2MMeNbK+jc9rrKVy280DnHO5JLMWOQ==} engines: {node: '>= 6.0.0'} + docker-compose@1.2.0: + resolution: {integrity: sha512-wIU1eHk3Op7dFgELRdmOYlPYS4gP8HhH1ZmZa13QZF59y0fblzFDFmKPhyc05phCy2hze9OEvNZAsoljrs+72w==} + engines: {node: '>= 6.0.0'} + docker-modem@1.0.9: resolution: {integrity: sha512-lVjqCSCIAUDZPAZIeyM125HXfNvOmYYInciphNrLrylUtKyW66meAjSPXWchKVzoIYZx69TPnAepVSSkeawoIw==} engines: {node: '>= 0.8'} @@ -1615,6 +1653,10 @@ packages: resolution: {integrity: sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==} engines: {node: '>=14.14'} + fs-extra@11.3.0: + resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==} + engines: {node: '>=14.14'} + fs-extra@9.1.0: resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} engines: {node: '>=10'} @@ -1672,6 +1714,11 @@ packages: engines: {node: 20 || >=22} hasBin: true + glob@11.0.2: + resolution: {integrity: sha512-YT7U7Vye+t5fZ/QMkBFrTJ7ZQxInIUjwyAjVj84CYXqgBdv30MFUPGnBR6sQaVq6Is15wYJUsnzTuWaGRBhBAQ==} + engines: {node: 20 || >=22} + hasBin: true + glob@7.2.3: resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} deprecated: Glob versions prior to v9 are no longer supported @@ -1758,9 +1805,6 @@ packages: resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==} engines: {node: '>=4'} - hash.js@1.1.3: - resolution: {integrity: sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==} - hash.js@1.1.7: resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} @@ -1814,6 +1858,9 @@ packages: immutable@5.0.3: resolution: {integrity: sha512-P8IdPQHq3lA1xVeBRi5VPqUm5HDgKnx0Ru51wZz5mjxHr5n3RWhjIpOFU7ybkUxfB+5IToy+OLaHYDBIWsv+uw==} + immutable@5.1.2: + resolution: {integrity: sha512-qHKXW1q6liAk1Oys6umoaZbDRqjcjgSrbnrifHsfsttza7zcvRAsL7mMV6xWcyhwQy7Xj5v4hhbr6b+iDYwlmQ==} + import-fresh@3.3.1: resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} engines: {node: '>=6'} @@ -2056,6 +2103,11 @@ packages: engines: {node: '>=8'} hasBin: true + jayson@4.2.0: + resolution: {integrity: sha512-VfJ9t1YLwacIubLhONk0KFeosUBwstRWQ0IRT1KDjEjnVnSOVHC3uwugyV7L0c7R9lpVyrUGT2XWiBA1UTtpyg==} + engines: {node: '>=8'} + hasBin: true + js-sha3@0.8.0: resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} @@ -2399,6 +2451,10 @@ packages: resolution: {integrity: sha512-mnkeQ1qP5Ue2wd+aivTD3NHd/lZ96Lu0jgf0pwktLPtx6cTZiH7tyeGRRHs0zX0rbrahXPnXlUnbeXyaBBuIaw==} engines: {node: '>=18'} + open@10.1.2: + resolution: {integrity: sha512-cxN6aIDPz6rm8hbebcP7vrQNhvRcveZoJU72Y7vskh4oIm+BZwBECnx5nTmrlres1Qapvx27Qo1Auukpf8PKXw==} + engines: {node: '>=18'} + open@8.4.2: resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==} engines: {node: '>=12'} @@ -2514,6 +2570,11 @@ packages: engines: {node: '>=14'} hasBin: true + prettier@3.5.3: + resolution: {integrity: sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==} + engines: {node: '>=14'} + hasBin: true + process-nextick-args@2.0.1: resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} @@ -2680,6 +2741,11 @@ packages: engines: {node: '>=10'} hasBin: true + semver@7.7.2: + resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==} + engines: {node: '>=10'} + hasBin: true + set-function-length@1.2.2: resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} engines: {node: '>= 0.4'} @@ -2749,6 +2815,12 @@ packages: engines: {node: '>=0.10.0'} hasBin: true + stream-chain@2.2.5: + resolution: {integrity: sha512-1TJmBx6aSWqZ4tx7aTpBDXK0/e2hhcNSTV8+CbFJtDjbb+I1mZ8lHit0Grw9GRT+6JbIrrDd8esncgBi8aBXGA==} + + stream-json@1.9.1: + resolution: {integrity: sha512-uWkjJ+2Nt/LO9Z/JyKZbMusL8Dkh97uUBTv3AJQ74y07lVahLY4eEFsPsE97pxYBwr8nnjMAIch5eqI0gPShyw==} + stream-to-it@0.2.4: resolution: {integrity: sha512-4vEbkSs83OahpmBybNJXlJd7d6/RxzkkSdT3I0mnGt79Xd2Kk+e1JqbvAvsQfCeKj3aKb0QIWkyK3/n0j506vQ==} @@ -2928,6 +3000,10 @@ packages: resolution: {integrity: sha512-WZkQ6eH9f5ZT93gaIffsbUaDpBwjbpvmMbfaEhOnbdUneurTESeRxwPGwjI28mRFESH3W3e8Togijh37ptOQqA==} engines: {node: '>=20.18.1'} + undici@7.9.0: + resolution: {integrity: sha512-e696y354tf5cFZPXsF26Yg+5M63+5H3oE6Vtkh2oqbvsE2Oe7s2nIbcQh5lmG7Lp/eS29vJtTpw9+p6PX0qNSg==} + engines: {node: '>=20.18.1'} + universalify@2.0.1: resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} engines: {node: '>= 10.0.0'} @@ -3083,6 +3159,11 @@ packages: engines: {node: '>= 14'} hasBin: true + yaml@2.8.0: + resolution: {integrity: sha512-4lLa/EcQCB0cJkyts+FpIRx5G/llPxfP6VQU5KByHEhLxY3IJCH0f0Hy1MHI8sClTvsIb8qwRJ6R/ZdlDJ/leQ==} + engines: {node: '>= 14.6'} + hasBin: true + yargs-parser@21.1.1: resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} engines: {node: '>=12'} @@ -3569,6 +3650,42 @@ snapshots: - utf-8-validate - zod + '@graphprotocol/graph-cli@0.97.1(@types/node@24.3.0)(bufferutil@4.0.9)(typescript@5.9.2)(utf-8-validate@5.0.10)(zod@3.25.76)': + dependencies: + '@float-capital/float-subgraph-uncrashable': 0.0.0-internal-testing.5 + '@oclif/core': 4.3.0 + '@oclif/plugin-autocomplete': 3.2.34 + '@oclif/plugin-not-found': 3.2.65(@types/node@24.3.0) + '@oclif/plugin-warn-if-update-available': 3.1.46 + '@pinax/graph-networks-registry': 0.6.7 + '@whatwg-node/fetch': 0.10.10 + assemblyscript: 0.19.23 + chokidar: 4.0.3 + debug: 4.4.1(supports-color@8.1.1) + docker-compose: 1.2.0 + fs-extra: 11.3.0 + glob: 11.0.2 + gluegun: 5.2.0(debug@4.4.1) + graphql: 16.11.0 + immutable: 5.1.2 + jayson: 4.2.0(bufferutil@4.0.9)(utf-8-validate@5.0.10) + js-yaml: 4.1.0 + kubo-rpc-client: 5.2.0(undici@7.9.0) + open: 10.1.2 + prettier: 3.5.3 + semver: 7.7.2 + tmp-promise: 3.0.3 + undici: 7.9.0 + web3-eth-abi: 4.4.1(typescript@5.9.2)(zod@3.25.76) + yaml: 2.8.0 + transitivePeerDependencies: + - '@types/node' + - bufferutil + - supports-color + - typescript + - utf-8-validate + - zod + '@graphprotocol/graph-ts@0.30.0': dependencies: assemblyscript: 0.19.10 @@ -3577,6 +3694,10 @@ snapshots: dependencies: assemblyscript: 0.19.10 + '@graphprotocol/graph-ts@0.33.0': + dependencies: + assemblyscript: 0.19.10 + '@graphprotocol/graph-ts@0.34.0': dependencies: assemblyscript: 0.19.10 @@ -3936,7 +4057,7 @@ snapshots: chalk: 4.1.2 clean-stack: 3.0.1 cli-progress: 3.12.0 - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.1(supports-color@8.1.1) ejs: 3.1.10 fs-extra: 9.1.0 get-package-type: 0.1.0 @@ -3948,7 +4069,7 @@ snapshots: natural-orderby: 2.0.3 object-treeify: 1.1.33 password-prompt: 1.1.3 - semver: 7.4.0 + semver: 7.6.3 string-width: 4.2.3 strip-ansi: 6.0.1 supports-color: 8.1.1 @@ -3985,6 +4106,27 @@ snapshots: wordwrap: 1.0.0 wrap-ansi: 7.0.0 + '@oclif/core@4.3.0': + dependencies: + ansi-escapes: 4.3.2 + ansis: 3.17.0 + clean-stack: 3.0.1 + cli-spinners: 2.9.2 + debug: 4.4.1(supports-color@8.1.1) + ejs: 3.1.10 + get-package-type: 0.1.0 + globby: 11.1.0 + indent-string: 4.0.0 + is-wsl: 2.2.0 + lilconfig: 3.1.3 + minimatch: 9.0.5 + semver: 7.7.2 + string-width: 4.2.3 + supports-color: 8.1.1 + widest-line: 3.1.0 + wordwrap: 1.0.0 + wrap-ansi: 7.0.0 + '@oclif/core@4.5.2': dependencies: ansi-escapes: 4.3.2 @@ -4146,7 +4288,7 @@ snapshots: '@types/concat-stream@1.6.1': dependencies: - '@types/node': 8.10.66 + '@types/node': 24.3.0 '@types/connect@3.4.38': dependencies: @@ -4158,7 +4300,7 @@ snapshots: '@types/form-data@0.0.33': dependencies: - '@types/node': 8.10.66 + '@types/node': 24.3.0 '@types/long@4.0.2': {} @@ -4316,6 +4458,12 @@ snapshots: transitivePeerDependencies: - debug + apisauce@2.1.6(debug@4.4.1): + dependencies: + axios: 0.21.4(debug@4.4.1) + transitivePeerDependencies: + - debug + app-module-path@2.2.0: {} arg@4.1.3: {} @@ -4381,6 +4529,12 @@ snapshots: transitivePeerDependencies: - debug + axios@0.21.4(debug@4.4.1): + dependencies: + follow-redirects: 1.15.11(debug@4.4.1) + transitivePeerDependencies: + - debug + axios@0.26.1(debug@4.3.7): dependencies: follow-redirects: 1.15.11(debug@4.3.7) @@ -4575,6 +4729,10 @@ snapshots: dependencies: readdirp: 4.1.2 + chokidar@4.0.3: + dependencies: + readdirp: 4.1.2 + chownr@1.1.4: {} chownr@2.0.0: {} @@ -4661,7 +4819,7 @@ snapshots: dependencies: cipher-base: 1.0.6 inherits: 2.0.4 - ripemd160: 2.0.1 + ripemd160: 2.0.2 sha.js: 2.4.12 create-hash@1.2.0: @@ -4759,7 +4917,7 @@ snapshots: dns-over-http-resolver@1.2.3(node-fetch@2.7.0(encoding@0.1.13)): dependencies: - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.1(supports-color@8.1.1) native-fetch: 3.0.0(node-fetch@2.7.0(encoding@0.1.13)) receptacle: 1.3.2 transitivePeerDependencies: @@ -4778,6 +4936,10 @@ snapshots: dependencies: yaml: 2.6.1 + docker-compose@1.2.0: + dependencies: + yaml: 2.8.0 + docker-modem@1.0.9: dependencies: JSONStream: 1.3.2 @@ -5006,6 +5168,10 @@ snapshots: optionalDependencies: debug: 4.3.7(supports-color@8.1.1) + follow-redirects@1.15.11(debug@4.4.1): + optionalDependencies: + debug: 4.4.1(supports-color@8.1.1) + for-each@0.3.5: dependencies: is-callable: 1.2.7 @@ -5040,6 +5206,12 @@ snapshots: jsonfile: 6.2.0 universalify: 2.0.1 + fs-extra@11.3.0: + dependencies: + graceful-fs: 4.2.11 + jsonfile: 6.2.0 + universalify: 2.0.1 + fs-extra@9.1.0: dependencies: at-least-node: 1.0.0 @@ -5106,6 +5278,15 @@ snapshots: package-json-from-dist: 1.0.1 path-scurry: 2.0.0 + glob@11.0.2: + dependencies: + foreground-child: 3.3.1 + jackspeak: 4.1.1 + minimatch: 10.0.3 + minipass: 7.1.2 + package-json-from-dist: 1.0.1 + path-scurry: 2.0.0 + glob@7.2.3: dependencies: fs.realpath: 1.0.0 @@ -5236,6 +5417,41 @@ snapshots: transitivePeerDependencies: - debug + gluegun@5.2.0(debug@4.4.1): + dependencies: + apisauce: 2.1.6(debug@4.4.1) + app-module-path: 2.2.0 + cli-table3: 0.6.0 + colors: 1.4.0 + cosmiconfig: 7.0.1 + cross-spawn: 7.0.3 + ejs: 3.1.8 + enquirer: 2.3.6 + execa: 5.1.1 + fs-jetpack: 4.3.1 + lodash.camelcase: 4.3.0 + lodash.kebabcase: 4.1.1 + lodash.lowercase: 4.3.0 + lodash.lowerfirst: 4.3.1 + lodash.pad: 4.5.1 + lodash.padend: 4.6.1 + lodash.padstart: 4.6.1 + lodash.repeat: 4.1.0 + lodash.snakecase: 4.1.1 + lodash.startcase: 4.4.0 + lodash.trim: 4.5.1 + lodash.trimend: 4.5.1 + lodash.trimstart: 4.5.1 + lodash.uppercase: 4.3.0 + lodash.upperfirst: 4.3.1 + ora: 4.0.2 + pluralize: 8.0.0 + semver: 7.3.5 + which: 2.0.2 + yargs-parser: 21.1.1 + transitivePeerDependencies: + - debug + gopd@1.2.0: {} graceful-fs@4.2.10: {} @@ -5283,11 +5499,6 @@ snapshots: readable-stream: 3.6.2 safe-buffer: 5.2.1 - hash.js@1.1.3: - dependencies: - inherits: 2.0.4 - minimalistic-assert: 1.0.1 - hash.js@1.1.7: dependencies: inherits: 2.0.4 @@ -5301,7 +5512,7 @@ snapshots: hmac-drbg@1.0.1: dependencies: - hash.js: 1.1.3 + hash.js: 1.1.7 minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 @@ -5349,6 +5560,8 @@ snapshots: immutable@5.0.3: {} + immutable@5.1.2: {} + import-fresh@3.3.1: dependencies: parent-module: 1.0.1 @@ -5396,7 +5609,7 @@ snapshots: any-signal: 2.1.2 blob-to-it: 1.0.4 browser-readablestream-to-it: 1.0.3 - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.1(supports-color@8.1.1) err-code: 3.0.1 ipfs-core-types: 0.9.0(node-fetch@2.7.0(encoding@0.1.13)) ipfs-unixfs: 6.0.9 @@ -5425,7 +5638,7 @@ snapshots: '@ipld/dag-pb': 2.1.18 abort-controller: 3.0.0 any-signal: 2.1.2 - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.1(supports-color@8.1.1) err-code: 3.0.1 ipfs-core-types: 0.9.0(node-fetch@2.7.0(encoding@0.1.13)) ipfs-core-utils: 0.13.0(encoding@0.1.13)(node-fetch@2.7.0(encoding@0.1.13)) @@ -5658,6 +5871,24 @@ snapshots: - bufferutil - utf-8-validate + jayson@4.2.0(bufferutil@4.0.9)(utf-8-validate@5.0.10): + dependencies: + '@types/connect': 3.4.38 + '@types/node': 12.20.55 + '@types/ws': 7.4.7 + commander: 2.20.3 + delay: 5.0.0 + es6-promisify: 5.0.0 + eyes: 0.1.8 + isomorphic-ws: 4.0.1(ws@7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10)) + json-stringify-safe: 5.0.1 + stream-json: 1.9.1 + uuid: 8.3.2 + ws: 7.5.10(bufferutil@4.0.9)(utf-8-validate@5.0.10) + transitivePeerDependencies: + - bufferutil + - utf-8-validate + js-sha3@0.8.0: {} js-tokens@4.0.0: {} @@ -5742,6 +5973,44 @@ snapshots: transitivePeerDependencies: - undici + kubo-rpc-client@5.2.0(undici@7.9.0): + dependencies: + '@ipld/dag-cbor': 9.2.4 + '@ipld/dag-json': 10.2.5 + '@ipld/dag-pb': 4.1.5 + '@libp2p/crypto': 5.1.7 + '@libp2p/interface': 2.10.5 + '@libp2p/logger': 5.1.21 + '@libp2p/peer-id': 5.1.8 + '@multiformats/multiaddr': 12.5.1 + '@multiformats/multiaddr-to-uri': 11.0.2 + any-signal: 4.1.1 + blob-to-it: 2.0.10 + browser-readablestream-to-it: 2.0.10 + dag-jose: 5.1.1 + electron-fetch: 1.9.1 + err-code: 3.0.1 + ipfs-unixfs: 11.2.5 + iso-url: 1.2.1 + it-all: 3.0.9 + it-first: 3.0.9 + it-glob: 3.0.4 + it-last: 3.0.9 + it-map: 3.1.4 + it-peekable: 3.0.8 + it-to-stream: 1.0.0 + merge-options: 3.0.4 + multiformats: 13.4.0 + nanoid: 5.1.5 + native-fetch: 4.0.2(undici@7.9.0) + parse-duration: 2.1.4 + react-native-fetch-api: 3.0.0 + stream-to-it: 1.0.1 + uint8arrays: 5.1.0 + wherearewe: 2.0.1 + transitivePeerDependencies: + - undici + lilconfig@3.1.3: {} lines-and-columns@1.2.4: {} @@ -5925,6 +6194,10 @@ snapshots: dependencies: undici: 7.1.1 + native-fetch@4.0.2(undici@7.9.0): + dependencies: + undici: 7.9.0 + natural-orderby@2.0.3: {} node-addon-api@2.0.2: {} @@ -5973,6 +6246,13 @@ snapshots: is-inside-container: 1.0.0 is-wsl: 3.1.0 + open@10.1.2: + dependencies: + default-browser: 5.2.1 + define-lazy-prop: 3.0.0 + is-inside-container: 1.0.0 + is-wsl: 3.1.0 + open@8.4.2: dependencies: define-lazy-prop: 2.0.0 @@ -6077,6 +6357,8 @@ snapshots: prettier@3.4.2: {} + prettier@3.5.3: {} + process-nextick-args@2.0.1: {} progress-events@1.0.1: {} @@ -6277,6 +6559,8 @@ snapshots: semver@7.6.3: {} + semver@7.7.2: {} + set-function-length@1.2.2: dependencies: define-data-property: 1.1.4 @@ -6363,6 +6647,12 @@ snapshots: safer-buffer: 2.1.2 tweetnacl: 0.14.5 + stream-chain@2.2.5: {} + + stream-json@1.9.1: + dependencies: + stream-chain: 2.2.5 + stream-to-it@0.2.4: dependencies: get-iterator: 1.0.2 @@ -6577,6 +6867,8 @@ snapshots: undici@7.1.1: {} + undici@7.9.0: {} + universalify@2.0.1: {} uri-js@4.4.1: @@ -6749,6 +7041,8 @@ snapshots: yaml@2.6.1: {} + yaml@2.8.0: {} + yargs-parser@21.1.1: {} yn@3.1.1: {} diff --git a/tests/.gitignore b/tests/.gitignore index 2015ffcd748..b3458a8f91a 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -1,3 +1,4 @@ contracts/cache/ +contracts/out/build-info/ integration-tests/graph-node.log integration-tests/*/subgraph.yaml.patched diff --git a/tests/contracts/abis/DeclaredCallsContract.json b/tests/contracts/abis/DeclaredCallsContract.json new file mode 100644 index 00000000000..5cce19559ef --- /dev/null +++ b/tests/contracts/abis/DeclaredCallsContract.json @@ -0,0 +1,532 @@ +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "alwaysReverts", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "assetOwners", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "assets", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "active", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "balanceOf", + "inputs": [ + { + "name": "account", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "balances", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "conditionalRevert", + "inputs": [], + "outputs": [], + "stateMutability": "view" + }, + { + "type": "function", + "name": "counter", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "emitAssetTransfer", + "inputs": [ + { + "name": "assetAddr", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "active", + "type": "bool", + "internalType": "bool" + }, + { + "name": "to", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "emitComplexAssetCreated", + "inputs": [ + { + "name": "baseAddr", + "type": "address", + "internalType": "address" + }, + { + "name": "baseAmount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "baseActive", + "type": "bool", + "internalType": "bool" + }, + { + "name": "metadataStr", + "type": "string", + "internalType": "string" + }, + { + "name": "values", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "id", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "emitTransfer", + "inputs": [ + { + "name": "from", + "type": "address", + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getAssetAmount", + "inputs": [ + { + "name": "assetId", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getConstant", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "getMetadata", + "inputs": [ + { + "name": "assetAddr", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOwner", + "inputs": [ + { + "name": "assetAddr", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "hiddenFunction", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "incrementCounter", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "isAssetActive", + "inputs": [ + { + "name": "assetId", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "metadata", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setShouldRevert", + "inputs": [ + { + "name": "_shouldRevert", + "type": "bool", + "internalType": "bool" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "shouldRevert", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "sum", + "inputs": [ + { + "name": "a", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "b", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "totalSupply", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AssetTransfer", + "inputs": [ + { + "name": "asset", + "type": "tuple", + "indexed": false, + "internalType": "struct DeclaredCallsContract.Asset", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "active", + "type": "bool", + "internalType": "bool" + } + ] + }, + { + "name": "to", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "blockNumber", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ComplexAssetCreated", + "inputs": [ + { + "name": "complexAsset", + "type": "tuple", + "indexed": false, + "internalType": "struct DeclaredCallsContract.ComplexAsset", + "components": [ + { + "name": "base", + "type": "tuple", + "internalType": "struct DeclaredCallsContract.Asset", + "components": [ + { + "name": "addr", + "type": "address", + "internalType": "address" + }, + { + "name": "amount", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "active", + "type": "bool", + "internalType": "bool" + } + ] + }, + { + "name": "metadata", + "type": "string", + "internalType": "string" + }, + { + "name": "values", + "type": "uint256[]", + "internalType": "uint256[]" + } + ] + }, + { + "name": "id", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Transfer", + "inputs": [ + { + "name": "from", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "to", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "value", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + } +] diff --git a/tests/contracts/abis/LimitedContract.json b/tests/contracts/abis/LimitedContract.json new file mode 100644 index 00000000000..6d68554ebad --- /dev/null +++ b/tests/contracts/abis/LimitedContract.json @@ -0,0 +1,32 @@ +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "inc", + "inputs": [ + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "event", + "name": "Trigger", + "inputs": [], + "anonymous": false + } +] diff --git a/tests/contracts/abis/OverloadedContract.json b/tests/contracts/abis/OverloadedContract.json new file mode 100644 index 00000000000..3c9efcf5215 --- /dev/null +++ b/tests/contracts/abis/OverloadedContract.json @@ -0,0 +1,70 @@ +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "exampleFunction", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "exampleFunction", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "exampleFunction", + "inputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "pure" + }, + { + "type": "event", + "name": "Trigger", + "inputs": [], + "anonymous": false + } +] diff --git a/tests/contracts/abis/RevertingContract.json b/tests/contracts/abis/RevertingContract.json new file mode 100644 index 00000000000..6d68554ebad --- /dev/null +++ b/tests/contracts/abis/RevertingContract.json @@ -0,0 +1,32 @@ +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "inc", + "inputs": [ + { + "name": "value", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "pure" + }, + { + "type": "event", + "name": "Trigger", + "inputs": [], + "anonymous": false + } +] diff --git a/tests/contracts/abis/SimpleContract.json b/tests/contracts/abis/SimpleContract.json new file mode 100644 index 00000000000..a977654ad89 --- /dev/null +++ b/tests/contracts/abis/SimpleContract.json @@ -0,0 +1,92 @@ +[ + { + "type": "constructor", + "inputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "emitAnotherTrigger", + "inputs": [ + { + "name": "a", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "b", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "c", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "data", + "type": "string", + "internalType": "string" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "emitTrigger", + "inputs": [ + { + "name": "x", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "AnotherTrigger", + "inputs": [ + { + "name": "a", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "b", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "c", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + }, + { + "name": "data", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Trigger", + "inputs": [ + { + "name": "x", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + } + ], + "anonymous": false + } +] diff --git a/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json b/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json new file mode 100644 index 00000000000..f88227bbd17 --- /dev/null +++ b/tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json @@ -0,0 +1 @@ +{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"alwaysReverts","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"pure"},{"type":"function","name":"assetOwners","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"assets","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"balanceOf","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"balances","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"conditionalRevert","inputs":[],"outputs":[],"stateMutability":"view"},{"type":"function","name":"counter","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"emitAssetTransfer","inputs":[{"name":"assetAddr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitComplexAssetCreated","inputs":[{"name":"baseAddr","type":"address","internalType":"address"},{"name":"baseAmount","type":"uint256","internalType":"uint256"},{"name":"baseActive","type":"bool","internalType":"bool"},{"name":"metadataStr","type":"string","internalType":"string"},{"name":"values","type":"uint256[]","internalType":"uint256[]"},{"name":"id","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitTransfer","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"getAssetAmount","inputs":[{"name":"assetId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"function","name":"getConstant","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"getMetadata","inputs":[{"name":"assetAddr","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"getOwner","inputs":[{"name":"assetAddr","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"function","name":"hiddenFunction","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"incrementCounter","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"type":"function","name":"isAssetActive","inputs":[{"name":"assetId","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"metadata","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"type":"function","name":"setShouldRevert","inputs":[{"name":"_shouldRevert","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"shouldRevert","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"function","name":"sum","inputs":[{"name":"a","type":"uint256","internalType":"uint256"},{"name":"b","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"type":"event","name":"AssetTransfer","inputs":[{"name":"asset","type":"tuple","indexed":false,"internalType":"struct DeclaredCallsContract.Asset","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}]},{"name":"to","type":"address","indexed":false,"internalType":"address"},{"name":"blockNumber","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"ComplexAssetCreated","inputs":[{"name":"complexAsset","type":"tuple","indexed":false,"internalType":"struct DeclaredCallsContract.ComplexAsset","components":[{"name":"base","type":"tuple","internalType":"struct DeclaredCallsContract.Asset","components":[{"name":"addr","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"active","type":"bool","internalType":"bool"}]},{"name":"metadata","type":"string","internalType":"string"},{"name":"values","type":"uint256[]","internalType":"uint256[]"}]},{"name":"id","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"type":"event","name":"Transfer","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false}],"bytecode":{"object":"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","sourceMap":"57:4967:0:-:0;;;1050:5;1023:32;;;;;;;;;;;;;;;;;;;;1086:1;1061:26;;1094:933;;;;;;;;;;1178:4;1155:8;:20;1164:10;1155:20;;;;;;;;;;;;;;;:27;;;;1256:4;1192:8;:61;1209:42;1192:61;;;;;;;;;;;;;;;:68;;;;1334:4;1270:8;:61;1287:42;1270:61;;;;;;;;;;;;;;;:68;;;;1362:4;1348:11;:18;;;;1424:139;;;;;;;;1458:42;1424:139;;;;;;1523:3;1424:139;;;;1548:4;1424:139;;;;;1412:6;:9;1419:1;1412:9;;;;;;;;;;;:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1590:10;1573:11;:14;1585:1;1573:14;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;1610:100;;;;;;;;;;;;;;;;;:8;:83;1640:42;1610:83;;;;;;;;;;;;;;;:100;;;;;;:::i;:::-;;1733:140;;;;;;;;1767:42;1733:140;;;;;;1832:3;1733:140;;;;1857:5;1733:140;;;;;1721:6;:9;1728:1;1721:9;;;;;;;;;;;:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1900:10;1883:11;:14;1895:1;1883:14;;;;;;;;;;;;:27;;;;;;;;;;;;;;;;;;1920:100;;;;;;;;;;;;;;;;;:8;:83;1950:42;1920:83;;;;;;;;;;;;;;;:100;;;;;;:::i;:::-;;57:4967;;7:99:1;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:180::-;160:77;157:1;150:88;257:4;254:1;247:15;281:4;278:1;271:15;298:180;346:77;343:1;336:88;443:4;440:1;433:15;467:4;464:1;457:15;484:320;528:6;565:1;559:4;555:12;545:22;;612:1;606:4;602:12;633:18;623:81;;689:4;681:6;677:17;667:27;;623:81;751:2;743:6;740:14;720:18;717:38;714:84;;770:18;;:::i;:::-;714:84;535:269;484:320;;;:::o;810:141::-;859:4;882:3;874:11;;905:3;902:1;895:14;939:4;936:1;926:18;918:26;;810:141;;;:::o;957:93::-;994:6;1041:2;1036;1029:5;1025:14;1021:23;1011:33;;957:93;;;:::o;1056:107::-;1100:8;1150:5;1144:4;1140:16;1119:37;;1056:107;;;;:::o;1169:393::-;1238:6;1288:1;1276:10;1272:18;1311:97;1341:66;1330:9;1311:97;:::i;:::-;1429:39;1459:8;1448:9;1429:39;:::i;:::-;1417:51;;1501:4;1497:9;1490:5;1486:21;1477:30;;1550:4;1540:8;1536:19;1529:5;1526:30;1516:40;;1245:317;;1169:393;;;;;:::o;1568:77::-;1605:7;1634:5;1623:16;;1568:77;;;:::o;1651:60::-;1679:3;1700:5;1693:12;;1651:60;;;:::o;1717:142::-;1767:9;1800:53;1818:34;1827:24;1845:5;1827:24;:::i;:::-;1818:34;:::i;:::-;1800:53;:::i;:::-;1787:66;;1717:142;;;:::o;1865:75::-;1908:3;1929:5;1922:12;;1865:75;;;:::o;1946:269::-;2056:39;2087:7;2056:39;:::i;:::-;2117:91;2166:41;2190:16;2166:41;:::i;:::-;2158:6;2151:4;2145:11;2117:91;:::i;:::-;2111:4;2104:105;2022:193;1946:269;;;:::o;2221:73::-;2266:3;2221:73;:::o;2300:189::-;2377:32;;:::i;:::-;2418:65;2476:6;2468;2462:4;2418:65;:::i;:::-;2353:136;2300:189;;:::o;2495:186::-;2555:120;2572:3;2565:5;2562:14;2555:120;;;2626:39;2663:1;2656:5;2626:39;:::i;:::-;2599:1;2592:5;2588:13;2579:22;;2555:120;;;2495:186;;:::o;2687:543::-;2788:2;2783:3;2780:11;2777:446;;;2822:38;2854:5;2822:38;:::i;:::-;2906:29;2924:10;2906:29;:::i;:::-;2896:8;2892:44;3089:2;3077:10;3074:18;3071:49;;;3110:8;3095:23;;3071:49;3133:80;3189:22;3207:3;3189:22;:::i;:::-;3179:8;3175:37;3162:11;3133:80;:::i;:::-;2792:431;;2777:446;2687:543;;;:::o;3236:117::-;3290:8;3340:5;3334:4;3330:16;3309:37;;3236:117;;;;:::o;3359:169::-;3403:6;3436:51;3484:1;3480:6;3472:5;3469:1;3465:13;3436:51;:::i;:::-;3432:56;3517:4;3511;3507:15;3497:25;;3410:118;3359:169;;;;:::o;3533:295::-;3609:4;3755:29;3780:3;3774:4;3755:29;:::i;:::-;3747:37;;3817:3;3814:1;3810:11;3804:4;3801:21;3793:29;;3533:295;;;;:::o;3833:1395::-;3950:37;3983:3;3950:37;:::i;:::-;4052:18;4044:6;4041:30;4038:56;;;4074:18;;:::i;:::-;4038:56;4118:38;4150:4;4144:11;4118:38;:::i;:::-;4203:67;4263:6;4255;4249:4;4203:67;:::i;:::-;4297:1;4321:4;4308:17;;4353:2;4345:6;4342:14;4370:1;4365:618;;;;5027:1;5044:6;5041:77;;;5093:9;5088:3;5084:19;5078:26;5069:35;;5041:77;5144:67;5204:6;5197:5;5144:67;:::i;:::-;5138:4;5131:81;5000:222;4335:887;;4365:618;4417:4;4413:9;4405:6;4401:22;4451:37;4483:4;4451:37;:::i;:::-;4510:1;4524:208;4538:7;4535:1;4532:14;4524:208;;;4617:9;4612:3;4608:19;4602:26;4594:6;4587:42;4668:1;4660:6;4656:14;4646:24;;4715:2;4704:9;4700:18;4687:31;;4561:4;4558:1;4554:12;4549:17;;4524:208;;;4760:6;4751:7;4748:19;4745:179;;;4818:9;4813:3;4809:19;4803:26;4861:48;4903:4;4895:6;4891:17;4880:9;4861:48;:::i;:::-;4853:6;4846:64;4768:156;4745:179;4970:1;4966;4958:6;4954:14;4950:22;4944:4;4937:36;4372:611;;;4335:887;;3925:1303;;;3833:1395;;:::o;57:4967:0:-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"57:4967:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;955:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2769:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3394:181;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;761:43;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2507:133;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;810:42;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3581:325;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3241:103;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1061:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4522:97;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;903:46;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2083:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2646:117;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4939:83;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2928:163;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3097:138;;;:::i;:::-;;4710:94;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3912:579;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;858:39;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;1023:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4625:79;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2196:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;955:26;;;;:::o;2769:113::-;2830:4;2853:6;:15;2860:7;2853:15;;;;;;;;;;;:22;;;;;;;;;;;;2846:29;;2769:113;;;:::o;3394:181::-;3492:5;3474:8;:14;3483:4;3474:14;;;;;;;;;;;;;;;;:23;;;;;;;:::i;:::-;;;;;;;;3523:5;3507:8;:12;3516:2;3507:12;;;;;;;;;;;;;;;;:21;;;;;;;:::i;:::-;;;;;;;;3558:2;3543:25;;3552:4;3543:25;;;3562:5;3543:25;;;;;;:::i;:::-;;;;;;;;3394:181;;;:::o;761:43::-;;;;;;;;;;;;;;;;;:::o;2507:133::-;2582:13;2614:8;:19;2623:9;2614:19;;;;;;;;;;;;;;;2607:26;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2507:133;;;:::o;810:42::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3581:325::-;3723:18;3744:102;;;;;;;;3770:9;3744:102;;;;;;3801:6;3744:102;;;;3829:6;3744:102;;;;;3723:123;;3861:38;3875:5;3882:2;3886:12;3861:38;;;;;;;;:::i;:::-;;;;;;;;3713:193;3581:325;;;;:::o;3241:103::-;3285:7;3304;;:9;;;;;;;;;:::i;:::-;;;;;;3330:7;;3323:14;;3241:103;:::o;1061:26::-;;;;:::o;4522:97::-;4599:13;4584:12;;:28;;;;;;;;;;;;;;;;;;4522:97;:::o;903:46::-;;;;;;;;;;;;;;;;;;;;;;:::o;2083:107::-;2140:7;2166:8;:17;2175:7;2166:17;;;;;;;;;;;;;;;;2159:24;;2083:107;;;:::o;2646:117::-;2708:7;2734:6;:15;2741:7;2734:15;;;;;;;;;;;:22;;;2727:29;;2646:117;;;:::o;4939:83::-;4986:7;5012:3;5005:10;;4939:83;:::o;2928:163::-;2974:4;2998:1;2994;:5;2990:74;;;3015:38;;;;;;;;;;:::i;:::-;;;;;;;;2990:74;3080:4;3073:11;;2928:163;:::o;3097:138::-;3152:12;;;;;;;;;;;3148:81;;;3180:38;;;;;;;;;;:::i;:::-;;;;;;;;3148:81;3097:138::o;4710:94::-;4766:7;4796:1;4792;:5;;;;:::i;:::-;4785:12;;4710:94;;;;:::o;3912:579::-;4135:22;4160:109;;;;;;;;4186:8;4160:109;;;;;;4216:10;4160:109;;;;4248:10;4160:109;;;;;4135:134;;4280:32;4315:116;;;;;;;;4348:9;4315:116;;;;4381:11;4315:116;;;;4414:6;4315:116;;;4280:151;;4447:37;4467:12;4481:2;4447:37;;;;;;;:::i;:::-;;;;;;;;4125:366;;3912:579;;;;;;:::o;858:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1023:32::-;;;;;;;;;;;;;:::o;4625:79::-;4669:7;4695:2;4688:9;;4625:79;:::o;2196:305::-;2254:7;2328:9;2340:1;2328:13;;2323:145;2348:2;2343:1;:7;2323:145;;2393:9;2375:27;;:6;:9;2382:1;2375:9;;;;;;;;;;;:14;;;;;;;;;;;;:27;;;2371:87;;2429:11;:14;2441:1;2429:14;;;;;;;;;;;;;;;;;;;;;2422:21;;;;;2371:87;2352:3;;;;;:::i;:::-;;;;2323:145;;;;2492:1;2477:17;;2196:305;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:75::-;475:6;508:2;502:9;492:19;;442:75;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:122;842:24;860:5;842:24;:::i;:::-;835:5;832:35;822:63;;881:1;878;871:12;822:63;769:122;:::o;897:139::-;943:5;981:6;968:20;959:29;;997:33;1024:5;997:33;:::i;:::-;897:139;;;;:::o;1042:329::-;1101:6;1150:2;1138:9;1129:7;1125:23;1121:32;1118:119;;;1156:79;;:::i;:::-;1118:119;1276:1;1301:53;1346:7;1337:6;1326:9;1322:22;1301:53;:::i;:::-;1291:63;;1247:117;1042:329;;;;:::o;1377:90::-;1411:7;1454:5;1447:13;1440:21;1429:32;;1377:90;;;:::o;1473:109::-;1554:21;1569:5;1554:21;:::i;:::-;1549:3;1542:34;1473:109;;:::o;1588:210::-;1675:4;1713:2;1702:9;1698:18;1690:26;;1726:65;1788:1;1777:9;1773:17;1764:6;1726:65;:::i;:::-;1588:210;;;;:::o;1804:126::-;1841:7;1881:42;1874:5;1870:54;1859:65;;1804:126;;;:::o;1936:96::-;1973:7;2002:24;2020:5;2002:24;:::i;:::-;1991:35;;1936:96;;;:::o;2038:122::-;2111:24;2129:5;2111:24;:::i;:::-;2104:5;2101:35;2091:63;;2150:1;2147;2140:12;2091:63;2038:122;:::o;2166:139::-;2212:5;2250:6;2237:20;2228:29;;2266:33;2293:5;2266:33;:::i;:::-;2166:139;;;;:::o;2311:619::-;2388:6;2396;2404;2453:2;2441:9;2432:7;2428:23;2424:32;2421:119;;;2459:79;;:::i;:::-;2421:119;2579:1;2604:53;2649:7;2640:6;2629:9;2625:22;2604:53;:::i;:::-;2594:63;;2550:117;2706:2;2732:53;2777:7;2768:6;2757:9;2753:22;2732:53;:::i;:::-;2722:63;;2677:118;2834:2;2860:53;2905:7;2896:6;2885:9;2881:22;2860:53;:::i;:::-;2850:63;;2805:118;2311:619;;;;;:::o;2936:329::-;2995:6;3044:2;3032:9;3023:7;3019:23;3015:32;3012:119;;;3050:79;;:::i;:::-;3012:119;3170:1;3195:53;3240:7;3231:6;3220:9;3216:22;3195:53;:::i;:::-;3185:63;;3141:117;2936:329;;;;:::o;3271:99::-;3323:6;3357:5;3351:12;3341:22;;3271:99;;;:::o;3376:169::-;3460:11;3494:6;3489:3;3482:19;3534:4;3529:3;3525:14;3510:29;;3376:169;;;;:::o;3551:246::-;3632:1;3642:113;3656:6;3653:1;3650:13;3642:113;;;3741:1;3736:3;3732:11;3726:18;3722:1;3717:3;3713:11;3706:39;3678:2;3675:1;3671:10;3666:15;;3642:113;;;3789:1;3780:6;3775:3;3771:16;3764:27;3613:184;3551:246;;;:::o;3803:102::-;3844:6;3895:2;3891:7;3886:2;3879:5;3875:14;3871:28;3861:38;;3803:102;;;:::o;3911:377::-;3999:3;4027:39;4060:5;4027:39;:::i;:::-;4082:71;4146:6;4141:3;4082:71;:::i;:::-;4075:78;;4162:65;4220:6;4215:3;4208:4;4201:5;4197:16;4162:65;:::i;:::-;4252:29;4274:6;4252:29;:::i;:::-;4247:3;4243:39;4236:46;;4003:285;3911:377;;;;:::o;4294:313::-;4407:4;4445:2;4434:9;4430:18;4422:26;;4494:9;4488:4;4484:20;4480:1;4469:9;4465:17;4458:47;4522:78;4595:4;4586:6;4522:78;:::i;:::-;4514:86;;4294:313;;;;:::o;4613:116::-;4683:21;4698:5;4683:21;:::i;:::-;4676:5;4673:32;4663:60;;4719:1;4716;4709:12;4663:60;4613:116;:::o;4735:133::-;4778:5;4816:6;4803:20;4794:29;;4832:30;4856:5;4832:30;:::i;:::-;4735:133;;;;:::o;4874:759::-;4957:6;4965;4973;4981;5030:3;5018:9;5009:7;5005:23;5001:33;4998:120;;;5037:79;;:::i;:::-;4998:120;5157:1;5182:53;5227:7;5218:6;5207:9;5203:22;5182:53;:::i;:::-;5172:63;;5128:117;5284:2;5310:53;5355:7;5346:6;5335:9;5331:22;5310:53;:::i;:::-;5300:63;;5255:118;5412:2;5438:50;5480:7;5471:6;5460:9;5456:22;5438:50;:::i;:::-;5428:60;;5383:115;5537:2;5563:53;5608:7;5599:6;5588:9;5584:22;5563:53;:::i;:::-;5553:63;;5508:118;4874:759;;;;;;;:::o;5639:323::-;5695:6;5744:2;5732:9;5723:7;5719:23;5715:32;5712:119;;;5750:79;;:::i;:::-;5712:119;5870:1;5895:50;5937:7;5928:6;5917:9;5913:22;5895:50;:::i;:::-;5885:60;;5841:114;5639:323;;;;:::o;5968:118::-;6055:24;6073:5;6055:24;:::i;:::-;6050:3;6043:37;5968:118;;:::o;6092:222::-;6185:4;6223:2;6212:9;6208:18;6200:26;;6236:71;6304:1;6293:9;6289:17;6280:6;6236:71;:::i;:::-;6092:222;;;;:::o;6320:474::-;6388:6;6396;6445:2;6433:9;6424:7;6420:23;6416:32;6413:119;;;6451:79;;:::i;:::-;6413:119;6571:1;6596:53;6641:7;6632:6;6621:9;6617:22;6596:53;:::i;:::-;6586:63;;6542:117;6698:2;6724:53;6769:7;6760:6;6749:9;6745:22;6724:53;:::i;:::-;6714:63;;6669:118;6320:474;;;;;:::o;6800:117::-;6909:1;6906;6899:12;6923:117;7032:1;7029;7022:12;7046:180;7094:77;7091:1;7084:88;7191:4;7188:1;7181:15;7215:4;7212:1;7205:15;7232:281;7315:27;7337:4;7315:27;:::i;:::-;7307:6;7303:40;7445:6;7433:10;7430:22;7409:18;7397:10;7394:34;7391:62;7388:88;;;7456:18;;:::i;:::-;7388:88;7496:10;7492:2;7485:22;7275:238;7232:281;;:::o;7519:129::-;7553:6;7580:20;;:::i;:::-;7570:30;;7609:33;7637:4;7629:6;7609:33;:::i;:::-;7519:129;;;:::o;7654:308::-;7716:4;7806:18;7798:6;7795:30;7792:56;;;7828:18;;:::i;:::-;7792:56;7866:29;7888:6;7866:29;:::i;:::-;7858:37;;7950:4;7944;7940:15;7932:23;;7654:308;;;:::o;7968:146::-;8065:6;8060:3;8055;8042:30;8106:1;8097:6;8092:3;8088:16;8081:27;7968:146;;;:::o;8120:425::-;8198:5;8223:66;8239:49;8281:6;8239:49;:::i;:::-;8223:66;:::i;:::-;8214:75;;8312:6;8305:5;8298:21;8350:4;8343:5;8339:16;8388:3;8379:6;8374:3;8370:16;8367:25;8364:112;;;8395:79;;:::i;:::-;8364:112;8485:54;8532:6;8527:3;8522;8485:54;:::i;:::-;8204:341;8120:425;;;;;:::o;8565:340::-;8621:5;8670:3;8663:4;8655:6;8651:17;8647:27;8637:122;;8678:79;;:::i;:::-;8637:122;8795:6;8782:20;8820:79;8895:3;8887:6;8880:4;8872:6;8868:17;8820:79;:::i;:::-;8811:88;;8627:278;8565:340;;;;:::o;8911:311::-;8988:4;9078:18;9070:6;9067:30;9064:56;;;9100:18;;:::i;:::-;9064:56;9150:4;9142:6;9138:17;9130:25;;9210:4;9204;9200:15;9192:23;;8911:311;;;:::o;9228:117::-;9337:1;9334;9327:12;9368:710;9464:5;9489:81;9505:64;9562:6;9505:64;:::i;:::-;9489:81;:::i;:::-;9480:90;;9590:5;9619:6;9612:5;9605:21;9653:4;9646:5;9642:16;9635:23;;9706:4;9698:6;9694:17;9686:6;9682:30;9735:3;9727:6;9724:15;9721:122;;;9754:79;;:::i;:::-;9721:122;9869:6;9852:220;9886:6;9881:3;9878:15;9852:220;;;9961:3;9990:37;10023:3;10011:10;9990:37;:::i;:::-;9985:3;9978:50;10057:4;10052:3;10048:14;10041:21;;9928:144;9912:4;9907:3;9903:14;9896:21;;9852:220;;;9856:21;9470:608;;9368:710;;;;;:::o;10101:370::-;10172:5;10221:3;10214:4;10206:6;10202:17;10198:27;10188:122;;10229:79;;:::i;:::-;10188:122;10346:6;10333:20;10371:94;10461:3;10453:6;10446:4;10438:6;10434:17;10371:94;:::i;:::-;10362:103;;10178:293;10101:370;;;;:::o;10477:1441::-;10613:6;10621;10629;10637;10645;10653;10702:3;10690:9;10681:7;10677:23;10673:33;10670:120;;;10709:79;;:::i;:::-;10670:120;10829:1;10854:53;10899:7;10890:6;10879:9;10875:22;10854:53;:::i;:::-;10844:63;;10800:117;10956:2;10982:53;11027:7;11018:6;11007:9;11003:22;10982:53;:::i;:::-;10972:63;;10927:118;11084:2;11110:50;11152:7;11143:6;11132:9;11128:22;11110:50;:::i;:::-;11100:60;;11055:115;11237:2;11226:9;11222:18;11209:32;11268:18;11260:6;11257:30;11254:117;;;11290:79;;:::i;:::-;11254:117;11395:63;11450:7;11441:6;11430:9;11426:22;11395:63;:::i;:::-;11385:73;;11180:288;11535:3;11524:9;11520:19;11507:33;11567:18;11559:6;11556:30;11553:117;;;11589:79;;:::i;:::-;11553:117;11694:78;11764:7;11755:6;11744:9;11740:22;11694:78;:::i;:::-;11684:88;;11478:304;11821:3;11848:53;11893:7;11884:6;11873:9;11869:22;11848:53;:::i;:::-;11838:63;;11792:119;10477:1441;;;;;;;;:::o;11924:430::-;12067:4;12105:2;12094:9;12090:18;12082:26;;12118:71;12186:1;12175:9;12171:17;12162:6;12118:71;:::i;:::-;12199:72;12267:2;12256:9;12252:18;12243:6;12199:72;:::i;:::-;12281:66;12343:2;12332:9;12328:18;12319:6;12281:66;:::i;:::-;11924:430;;;;;;:::o;12360:180::-;12408:77;12405:1;12398:88;12505:4;12502:1;12495:15;12529:4;12526:1;12519:15;12546:194;12586:4;12606:20;12624:1;12606:20;:::i;:::-;12601:25;;12640:20;12658:1;12640:20;:::i;:::-;12635:25;;12684:1;12681;12677:9;12669:17;;12708:1;12702:4;12699:11;12696:37;;;12713:18;;:::i;:::-;12696:37;12546:194;;;;:::o;12746:191::-;12786:3;12805:20;12823:1;12805:20;:::i;:::-;12800:25;;12839:20;12857:1;12839:20;:::i;:::-;12834:25;;12882:1;12879;12875:9;12868:16;;12903:3;12900:1;12897:10;12894:36;;;12910:18;;:::i;:::-;12894:36;12746:191;;;;:::o;12943:180::-;12991:77;12988:1;12981:88;13088:4;13085:1;13078:15;13112:4;13109:1;13102:15;13129:320;13173:6;13210:1;13204:4;13200:12;13190:22;;13257:1;13251:4;13247:12;13278:18;13268:81;;13334:4;13326:6;13322:17;13312:27;;13268:81;13396:2;13388:6;13385:14;13365:18;13362:38;13359:84;;13415:18;;:::i;:::-;13359:84;13180:269;13129:320;;;:::o;13455:108::-;13532:24;13550:5;13532:24;:::i;:::-;13527:3;13520:37;13455:108;;:::o;13569:::-;13646:24;13664:5;13646:24;:::i;:::-;13641:3;13634:37;13569:108;;:::o;13683:99::-;13754:21;13769:5;13754:21;:::i;:::-;13749:3;13742:34;13683:99;;:::o;13868:669::-;14005:4;14000:3;13996:14;14092:4;14085:5;14081:16;14075:23;14111:63;14168:4;14163:3;14159:14;14145:12;14111:63;:::i;:::-;14020:164;14268:4;14261:5;14257:16;14251:23;14287:63;14344:4;14339:3;14335:14;14321:12;14287:63;:::i;:::-;14194:166;14444:4;14437:5;14433:16;14427:23;14463:57;14514:4;14509:3;14505:14;14491:12;14463:57;:::i;:::-;14370:160;13974:563;13868:669;;:::o;14543:524::-;14732:4;14770:3;14759:9;14755:19;14747:27;;14784:111;14892:1;14881:9;14877:17;14868:6;14784:111;:::i;:::-;14905:72;14973:2;14962:9;14958:18;14949:6;14905:72;:::i;:::-;14987:73;15055:3;15044:9;15040:19;15031:6;14987:73;:::i;:::-;14543:524;;;;;;:::o;15073:233::-;15112:3;15135:24;15153:5;15135:24;:::i;:::-;15126:33;;15181:66;15174:5;15171:77;15168:103;;15251:18;;:::i;:::-;15168:103;15298:1;15291:5;15287:13;15280:20;;15073:233;;;:::o;15312:178::-;15452:30;15448:1;15440:6;15436:14;15429:54;15312:178;:::o;15496:366::-;15638:3;15659:67;15723:2;15718:3;15659:67;:::i;:::-;15652:74;;15735:93;15824:3;15735:93;:::i;:::-;15853:2;15848:3;15844:12;15837:19;;15496:366;;;:::o;15868:419::-;16034:4;16072:2;16061:9;16057:18;16049:26;;16121:9;16115:4;16111:20;16107:1;16096:9;16092:17;16085:47;16149:131;16275:4;16149:131;:::i;:::-;16141:139;;15868:419;;;:::o;16293:178::-;16433:30;16429:1;16421:6;16417:14;16410:54;16293:178;:::o;16477:366::-;16619:3;16640:67;16704:2;16699:3;16640:67;:::i;:::-;16633:74;;16716:93;16805:3;16716:93;:::i;:::-;16834:2;16829:3;16825:12;16818:19;;16477:366;;;:::o;16849:419::-;17015:4;17053:2;17042:9;17038:18;17030:26;;17102:9;17096:4;17092:20;17088:1;17077:9;17073:17;17066:47;17130:131;17256:4;17130:131;:::i;:::-;17122:139;;16849:419;;;:::o;17354:659::-;17481:4;17476:3;17472:14;17568:4;17561:5;17557:16;17551:23;17587:63;17644:4;17639:3;17635:14;17621:12;17587:63;:::i;:::-;17496:164;17744:4;17737:5;17733:16;17727:23;17763:63;17820:4;17815:3;17811:14;17797:12;17763:63;:::i;:::-;17670:166;17920:4;17913:5;17909:16;17903:23;17939:57;17990:4;17985:3;17981:14;17967:12;17939:57;:::i;:::-;17846:160;17450:563;17354:659;;:::o;18019:159::-;18093:11;18127:6;18122:3;18115:19;18167:4;18162:3;18158:14;18143:29;;18019:159;;;;:::o;18184:357::-;18262:3;18290:39;18323:5;18290:39;:::i;:::-;18345:61;18399:6;18394:3;18345:61;:::i;:::-;18338:68;;18415:65;18473:6;18468:3;18461:4;18454:5;18450:16;18415:65;:::i;:::-;18505:29;18527:6;18505:29;:::i;:::-;18500:3;18496:39;18489:46;;18266:275;18184:357;;;;:::o;18547:114::-;18614:6;18648:5;18642:12;18632:22;;18547:114;;;:::o;18667:174::-;18756:11;18790:6;18785:3;18778:19;18830:4;18825:3;18821:14;18806:29;;18667:174;;;;:::o;18847:132::-;18914:4;18937:3;18929:11;;18967:4;18962:3;18958:14;18950:22;;18847:132;;;:::o;18985:179::-;19054:10;19075:46;19117:3;19109:6;19075:46;:::i;:::-;19153:4;19148:3;19144:14;19130:28;;18985:179;;;;:::o;19170:113::-;19240:4;19272;19267:3;19263:14;19255:22;;19170:113;;;:::o;19319:712::-;19428:3;19457:54;19505:5;19457:54;:::i;:::-;19527:76;19596:6;19591:3;19527:76;:::i;:::-;19520:83;;19627:56;19677:5;19627:56;:::i;:::-;19706:7;19737:1;19722:284;19747:6;19744:1;19741:13;19722:284;;;19823:6;19817:13;19850:63;19909:3;19894:13;19850:63;:::i;:::-;19843:70;;19936:60;19989:6;19936:60;:::i;:::-;19926:70;;19782:224;19769:1;19766;19762:9;19757:14;;19722:284;;;19726:14;20022:3;20015:10;;19433:598;;;19319:712;;;;:::o;20131:933::-;20256:3;20292:4;20287:3;20283:14;20379:4;20372:5;20368:16;20362:23;20398:103;20495:4;20490:3;20486:14;20472:12;20398:103;:::i;:::-;20307:204;20597:4;20590:5;20586:16;20580:23;20650:3;20644:4;20640:14;20633:4;20628:3;20624:14;20617:38;20676:73;20744:4;20730:12;20676:73;:::i;:::-;20668:81;;20521:239;20844:4;20837:5;20833:16;20827:23;20897:3;20891:4;20887:14;20880:4;20875:3;20871:14;20864:38;20923:103;21021:4;21007:12;20923:103;:::i;:::-;20915:111;;20770:267;21054:4;21047:11;;20261:803;20131:933;;;;:::o;21070:495::-;21247:4;21285:2;21274:9;21270:18;21262:26;;21334:9;21328:4;21324:20;21320:1;21309:9;21305:17;21298:47;21362:114;21471:4;21462:6;21362:114;:::i;:::-;21354:122;;21486:72;21554:2;21543:9;21539:18;21530:6;21486:72;:::i;:::-;21070:495;;;;;:::o","linkReferences":{}},"methodIdentifiers":{"alwaysReverts()":"b4f5537d","assetOwners(uint256)":"6999f843","assets(uint256)":"cf35bdd0","balanceOf(address)":"70a08231","balances(address)":"27e235e3","conditionalRevert()":"bcd0aaf8","counter()":"61bc221a","emitAssetTransfer(address,uint256,bool,address)":"4d6f9982","emitComplexAssetCreated(address,uint256,bool,string,uint256[],uint256)":"cd63468a","emitTransfer(address,address,uint256)":"23de6651","getAssetAmount(uint256)":"92eaff83","getConstant()":"f13a38a6","getMetadata(address)":"2a50c146","getOwner(address)":"fa544161","hiddenFunction()":"a718c0d9","incrementCounter()":"5b34b966","isAssetActive(uint256)":"22e900c2","metadata(address)":"2ba21572","setShouldRevert(bool)":"6813d787","shouldRevert()":"d3072d82","sum(uint256,uint256)":"cad0899b","totalSupply()":"18160ddd"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"indexed\":false,\"internalType\":\"struct DeclaredCallsContract.Asset\",\"name\":\"asset\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"AssetTransfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"internalType\":\"struct DeclaredCallsContract.Asset\",\"name\":\"base\",\"type\":\"tuple\"},{\"internalType\":\"string\",\"name\":\"metadata\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"indexed\":false,\"internalType\":\"struct DeclaredCallsContract.ComplexAsset\",\"name\":\"complexAsset\",\"type\":\"tuple\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"ComplexAssetCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"alwaysReverts\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"assetOwners\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"assets\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"conditionalRevert\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"counter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"active\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"emitAssetTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseAddr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"baseAmount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"baseActive\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"metadataStr\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"emitComplexAssetCreated\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"emitTransfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assetId\",\"type\":\"uint256\"}],\"name\":\"getAssetAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getConstant\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"}],\"name\":\"getMetadata\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"assetAddr\",\"type\":\"address\"}],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"hiddenFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"assetId\",\"type\":\"uint256\"}],\"name\":\"isAssetActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"metadata\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_shouldRevert\",\"type\":\"bool\"}],\"name\":\"setShouldRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"shouldRevert\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"}],\"name\":\"sum\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/DeclaredCallsContract.sol\":\"DeclaredCallsContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/DeclaredCallsContract.sol\":{\"keccak256\":\"0xb7dd6115ebb33909cd2861b46faf38ee9d054bcb7e47e69824598be15348c72b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://850a9682211cb8dd788de77cb14735d90c8aa4c907a0cf32703af687ce0a48f3\",\"dweb:/ipfs/Qmad15X9aQ3aYWJX71RPVkn42NWW2t5bjFFm1ESqAgRo4b\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"struct DeclaredCallsContract.Asset","name":"asset","type":"tuple","components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}],"indexed":false},{"internalType":"address","name":"to","type":"address","indexed":false},{"internalType":"uint256","name":"blockNumber","type":"uint256","indexed":false}],"type":"event","name":"AssetTransfer","anonymous":false},{"inputs":[{"internalType":"struct DeclaredCallsContract.ComplexAsset","name":"complexAsset","type":"tuple","components":[{"internalType":"struct DeclaredCallsContract.Asset","name":"base","type":"tuple","components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}]},{"internalType":"string","name":"metadata","type":"string"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"indexed":false},{"internalType":"uint256","name":"id","type":"uint256","indexed":false}],"type":"event","name":"ComplexAssetCreated","anonymous":false},{"inputs":[{"internalType":"address","name":"from","type":"address","indexed":true},{"internalType":"address","name":"to","type":"address","indexed":true},{"internalType":"uint256","name":"value","type":"uint256","indexed":false}],"type":"event","name":"Transfer","anonymous":false},{"inputs":[],"stateMutability":"pure","type":"function","name":"alwaysReverts","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"assetOwners","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function","name":"assets","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"}]},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"stateMutability":"view","type":"function","name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function","name":"balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"conditionalRevert"},{"inputs":[],"stateMutability":"view","type":"function","name":"counter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"},{"internalType":"address","name":"to","type":"address"}],"stateMutability":"nonpayable","type":"function","name":"emitAssetTransfer"},{"inputs":[{"internalType":"address","name":"baseAddr","type":"address"},{"internalType":"uint256","name":"baseAmount","type":"uint256"},{"internalType":"bool","name":"baseActive","type":"bool"},{"internalType":"string","name":"metadataStr","type":"string"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"uint256","name":"id","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"emitComplexAssetCreated"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"nonpayable","type":"function","name":"emitTransfer"},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"stateMutability":"view","type":"function","name":"getAssetAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"pure","type":"function","name":"getConstant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"}],"stateMutability":"view","type":"function","name":"getMetadata","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"address","name":"assetAddr","type":"address"}],"stateMutability":"view","type":"function","name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}]},{"inputs":[],"stateMutability":"pure","type":"function","name":"hiddenFunction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"nonpayable","type":"function","name":"incrementCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"assetId","type":"uint256"}],"stateMutability":"view","type":"function","name":"isAssetActive","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function","name":"metadata","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"bool","name":"_shouldRevert","type":"bool"}],"stateMutability":"nonpayable","type":"function","name":"setShouldRevert"},{"inputs":[],"stateMutability":"view","type":"function","name":"shouldRevert","outputs":[{"internalType":"bool","name":"","type":"bool"}]},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"stateMutability":"pure","type":"function","name":"sum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[],"stateMutability":"view","type":"function","name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/DeclaredCallsContract.sol":"DeclaredCallsContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/DeclaredCallsContract.sol":{"keccak256":"0xb7dd6115ebb33909cd2861b46faf38ee9d054bcb7e47e69824598be15348c72b","urls":["bzz-raw://850a9682211cb8dd788de77cb14735d90c8aa4c907a0cf32703af687ce0a48f3","dweb:/ipfs/Qmad15X9aQ3aYWJX71RPVkn42NWW2t5bjFFm1ESqAgRo4b"],"license":"MIT"}},"version":1},"id":0} \ No newline at end of file diff --git a/tests/contracts/out/LimitedContract.sol/LimitedContract.json b/tests/contracts/out/LimitedContract.sol/LimitedContract.json index f853978ad6c..bb294ec8664 100644 --- a/tests/contracts/out/LimitedContract.sol/LimitedContract.json +++ b/tests/contracts/out/LimitedContract.sol/LimitedContract.json @@ -1 +1 @@ -{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610120806100496000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea264697066735822122045679e894d199dcf13e7f3e6d9816bf08cd9cceab355500d502bbfada548205f64736f6c63430008130033","sourceMap":"57:257:0:-:0;;;110:45;;;;;;;;;-1:-1:-1;139:9:0;;;;;;;57:257;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea264697066735822122045679e894d199dcf13e7f3e6d9816bf08cd9cceab355500d502bbfada548205f64736f6c63430008130033","sourceMap":"57:257:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;161:151;;;;;;:::i;:::-;;:::i;:::-;;;345:25:4;;;333:2;318:18;161:151:0;;;;;;;;210:7;245:2;237:5;:10;229:50;;;;-1:-1:-1;;;229:50:0;;583:2:4;229:50:0;;;565:21:4;622:2;602:18;;;595:30;661:29;641:18;;;634:57;708:18;;229:50:0;;;;;;;;296:9;:5;304:1;296:9;:::i;:::-;289:16;161:151;-1:-1:-1;;161:151:0:o;14:180:4:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:4;;14:180;-1:-1:-1;14:180:4:o;737:222::-;802:9;;;823:10;;;820:133;;;875:10;870:3;866:20;863:1;856:31;910:4;907:1;900:15;938:4;935:1;928:15","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LimitedContract.sol\":\"LimitedContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/LimitedContract.sol\":{\"keccak256\":\"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb\",\"dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.19+commit.7dd6d404"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/LimitedContract.sol":"LimitedContract"},"evmVersion":"paris","libraries":{}},"sources":{"src/LimitedContract.sol":{"keccak256":"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02","urls":["bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb","dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut"],"license":"MIT"}},"version":1},"ast":{"absolutePath":"src/LimitedContract.sol","id":31,"exportedSymbols":{"LimitedContract":[30]},"nodeType":"SourceUnit","src":"32:283:0","nodes":[{"id":1,"nodeType":"PragmaDirective","src":"32:23:0","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":30,"nodeType":"ContractDefinition","src":"57:257:0","nodes":[{"id":3,"nodeType":"EventDefinition","src":"88:16:0","nodes":[],"anonymous":false,"eventSelector":"3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d","name":"Trigger","nameLocation":"94:7:0","parameters":{"id":2,"nodeType":"ParameterList","parameters":[],"src":"101:2:0"}},{"id":10,"nodeType":"FunctionDefinition","src":"110:45:0","nodes":[],"body":{"id":9,"nodeType":"Block","src":"124:31:0","nodes":[],"statements":[{"eventCall":{"arguments":[],"expression":{"argumentTypes":[],"id":6,"name":"Trigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":3,"src":"139:7:0","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$__$returns$__$","typeString":"function ()"}},"id":7,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"139:9:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":8,"nodeType":"EmitStatement","src":"134:14:0"}]},"implemented":true,"kind":"constructor","modifiers":[],"name":"","nameLocation":"-1:-1:-1","parameters":{"id":4,"nodeType":"ParameterList","parameters":[],"src":"121:2:0"},"returnParameters":{"id":5,"nodeType":"ParameterList","parameters":[],"src":"124:0:0"},"scope":30,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":29,"nodeType":"FunctionDefinition","src":"161:151:0","nodes":[],"body":{"id":28,"nodeType":"Block","src":"219:93:0","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":20,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":18,"name":"value","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":12,"src":"237:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"<","rightExpression":{"hexValue":"3130","id":19,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"245:2:0","typeDescriptions":{"typeIdentifier":"t_rational_10_by_1","typeString":"int_const 10"},"value":"10"},"src":"237:10:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"63616e206f6e6c792068616e646c652076616c756573203c203130","id":21,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"249:29:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449","typeString":"literal_string \"can only handle values < 10\""},"value":"can only handle values < 10"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449","typeString":"literal_string \"can only handle values < 10\""}],"id":17,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"229:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":22,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"229:50:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":23,"nodeType":"ExpressionStatement","src":"229:50:0"},{"expression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":26,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":24,"name":"value","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":12,"src":"296:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"31","id":25,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"304:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"src":"296:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"functionReturnParameters":16,"id":27,"nodeType":"Return","src":"289:16:0"}]},"functionSelector":"812600df","implemented":true,"kind":"function","modifiers":[],"name":"inc","nameLocation":"170:3:0","parameters":{"id":13,"nodeType":"ParameterList","parameters":[{"constant":false,"id":12,"mutability":"mutable","name":"value","nameLocation":"182:5:0","nodeType":"VariableDeclaration","scope":29,"src":"174:13:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":11,"name":"uint256","nodeType":"ElementaryTypeName","src":"174:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"173:15:0"},"returnParameters":{"id":16,"nodeType":"ParameterList","parameters":[{"constant":false,"id":15,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":29,"src":"210:7:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":14,"name":"uint256","nodeType":"ElementaryTypeName","src":"210:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"209:9:0"},"scope":30,"stateMutability":"pure","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"LimitedContract","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[30],"name":"LimitedContract","nameLocation":"66:15:0","scope":31,"usedErrors":[]}],"license":"MIT"},"id":0} \ No newline at end of file +{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561000f575f80fd5b507f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d60405160405180910390a161024d806100495f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea264697066735822122016a7fef0e372985eb6471669f69fb86efa228ea461eb16a899a782e4bb3f533b64736f6c63430008160033","sourceMap":"57:257:1:-:0;;;110:45;;;;;;;;;;139:9;;;;;;;;;;57:257;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea264697066735822122016a7fef0e372985eb6471669f69fb86efa228ea461eb16a899a782e4bb3f533b64736f6c63430008160033","sourceMap":"57:257:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;161:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;210:7;245:2;237:5;:10;229:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;304:1;296:5;:9;;;;:::i;:::-;289:16;;161:151;;;:::o;88:117:5:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:169::-;1461:11;1495:6;1490:3;1483:19;1535:4;1530:3;1526:14;1511:29;;1377:169;;;;:::o;1552:177::-;1692:29;1688:1;1680:6;1676:14;1669:53;1552:177;:::o;1735:366::-;1877:3;1898:67;1962:2;1957:3;1898:67;:::i;:::-;1891:74;;1974:93;2063:3;1974:93;:::i;:::-;2092:2;2087:3;2083:12;2076:19;;1735:366;;;:::o;2107:419::-;2273:4;2311:2;2300:9;2296:18;2288:26;;2360:9;2354:4;2350:20;2346:1;2335:9;2331:17;2324:47;2388:131;2514:4;2388:131;:::i;:::-;2380:139;;2107:419;;;:::o;2532:180::-;2580:77;2577:1;2570:88;2677:4;2674:1;2667:15;2701:4;2698:1;2691:15;2718:191;2758:3;2777:20;2795:1;2777:20;:::i;:::-;2772:25;;2811:20;2829:1;2811:20;:::i;:::-;2806:25;;2854:1;2851;2847:9;2840:16;;2875:3;2872:1;2869:10;2866:36;;;2882:18;;:::i;:::-;2866:36;2718:191;;;;:::o","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LimitedContract.sol\":\"LimitedContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/LimitedContract.sol\":{\"keccak256\":\"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb\",\"dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/LimitedContract.sol":"LimitedContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/LimitedContract.sol":{"keccak256":"0x7b291e6c8d7562ba65f036bd8b25c87587c57f5c35d5a6ea587a4eb6c7de4b02","urls":["bzz-raw://b7b7d9ad73d3f266dff610553eac7a1454f71e616036b0b50cee8610b999c2eb","dweb:/ipfs/QmcdMqSxkNDwHJ8pMyh2jK2sA6Xrk4VSdm4nqZ86EK2Vut"],"license":"MIT"}},"version":1},"id":1} \ No newline at end of file diff --git a/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json b/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json index 5c4fc74d7cf..c0d7d2f52a0 100644 --- a/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json +++ b/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json @@ -1 +1 @@ -{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"string","internalType":"string"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610252806100496000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806331870cbc14610046578063934bc29d1461006e578063bc2d73ba146100b5575b600080fd5b61005b6100543660046100ee565b5061010090565b6040519081526020015b60405180910390f35b6100a861007c3660046100ee565b5060408051808201909152601181527075696e74323536202d3e20737472696e6760781b602082015290565b6040516100659190610107565b6100a86100c336600461016b565b5060408051808201909152601081526f737472696e67202d3e20737472696e6760801b602082015290565b60006020828403121561010057600080fd5b5035919050565b600060208083528351808285015260005b8181101561013457858101830151858201604001528201610118565b506000604082860101526040601f19601f8301168501019250505092915050565b634e487b7160e01b600052604160045260246000fd5b60006020828403121561017d57600080fd5b813567ffffffffffffffff8082111561019557600080fd5b818401915084601f8301126101a957600080fd5b8135818111156101bb576101bb610155565b604051601f8201601f19908116603f011681019083821181831017156101e3576101e3610155565b816040528281528760208487010111156101fc57600080fd5b82602086016020830137600092810160200192909252509594505050505056fea2646970667358221220d7abec9e326f4c25cc8f45f8ee265c92b595b8cf7f1d5a1d863735dee11ed7d064736f6c63430008130033","sourceMap":"57:457:1:-:0;;;113:45;;;;;;;;;-1:-1:-1;142:9:1;;;;;;;57:457;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561001057600080fd5b50600436106100415760003560e01c806331870cbc14610046578063934bc29d1461006e578063bc2d73ba146100b5575b600080fd5b61005b6100543660046100ee565b5061010090565b6040519081526020015b60405180910390f35b6100a861007c3660046100ee565b5060408051808201909152601181527075696e74323536202d3e20737472696e6760781b602082015290565b6040516100659190610107565b6100a86100c336600461016b565b5060408051808201909152601081526f737472696e67202d3e20737472696e6760801b602082015290565b60006020828403121561010057600080fd5b5035919050565b600060208083528351808285015260005b8181101561013457858101830151858201604001528201610118565b506000604082860101526040601f19601f8301168501019250505092915050565b634e487b7160e01b600052604160045260246000fd5b60006020828403121561017d57600080fd5b813567ffffffffffffffff8082111561019557600080fd5b818401915084601f8301126101a957600080fd5b8135818111156101bb576101bb610155565b604051601f8201601f19908116603f011681019083821181831017156101e3576101e3610155565b816040528281528760208487010111156101fc57600080fd5b82602086016020830137600092810160200192909252509594505050505056fea2646970667358221220d7abec9e326f4c25cc8f45f8ee265c92b595b8cf7f1d5a1d863735dee11ed7d064736f6c63430008130033","sourceMap":"57:457:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;421:91;;;;;;:::i;:::-;-1:-1:-1;502:3:1;;421:91;;;;345:25:4;;;333:2;318:18;421:91:1;;;;;;;;302:113;;;;;;:::i;:::-;-1:-1:-1;382:26:1;;;;;;;;;;;;-1:-1:-1;;;382:26:1;;;;;302:113;;;;;;;;:::i;164:132::-;;;;;;:::i;:::-;-1:-1:-1;264:25:1;;;;;;;;;;;;-1:-1:-1;;;264:25:1;;;;;164:132;14:180:4;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:4;;14:180;-1:-1:-1;14:180:4:o;566:548::-;678:4;707:2;736;725:9;718:21;768:6;762:13;811:6;806:2;795:9;791:18;784:34;836:1;846:140;860:6;857:1;854:13;846:140;;;955:14;;;951:23;;945:30;921:17;;;940:2;917:26;910:66;875:10;;846:140;;;850:3;1035:1;1030:2;1021:6;1010:9;1006:22;1002:31;995:42;1105:2;1098;1094:7;1089:2;1081:6;1077:15;1073:29;1062:9;1058:45;1054:54;1046:62;;;;566:548;;;;:::o;1119:127::-;1180:10;1175:3;1171:20;1168:1;1161:31;1211:4;1208:1;1201:15;1235:4;1232:1;1225:15;1251:922;1320:6;1373:2;1361:9;1352:7;1348:23;1344:32;1341:52;;;1389:1;1386;1379:12;1341:52;1429:9;1416:23;1458:18;1499:2;1491:6;1488:14;1485:34;;;1515:1;1512;1505:12;1485:34;1553:6;1542:9;1538:22;1528:32;;1598:7;1591:4;1587:2;1583:13;1579:27;1569:55;;1620:1;1617;1610:12;1569:55;1656:2;1643:16;1678:2;1674;1671:10;1668:36;;;1684:18;;:::i;:::-;1759:2;1753:9;1727:2;1813:13;;-1:-1:-1;;1809:22:4;;;1833:2;1805:31;1801:40;1789:53;;;1857:18;;;1877:22;;;1854:46;1851:72;;;1903:18;;:::i;:::-;1943:10;1939:2;1932:22;1978:2;1970:6;1963:18;2018:7;2013:2;2008;2004;2000:11;1996:20;1993:33;1990:53;;;2039:1;2036;2029:12;1990:53;2095:2;2090;2086;2082:11;2077:2;2069:6;2065:15;2052:46;2140:1;2118:15;;;2135:2;2114:24;2107:35;;;;-1:-1:-1;2122:6:4;1251:922;-1:-1:-1;;;;;1251:922:4:o","linkReferences":{}},"methodIdentifiers":{"exampleFunction(bytes32)":"31870cbc","exampleFunction(string)":"bc2d73ba","exampleFunction(uint256)":"934bc29d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OverloadedContract.sol\":\"OverloadedContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/OverloadedContract.sol\":{\"keccak256\":\"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be\",\"dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.19+commit.7dd6d404"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/OverloadedContract.sol":"OverloadedContract"},"evmVersion":"paris","libraries":{}},"sources":{"src/OverloadedContract.sol":{"keccak256":"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45","urls":["bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be","dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe"],"license":"MIT"}},"version":1},"ast":{"absolutePath":"src/OverloadedContract.sol","id":73,"exportedSymbols":{"OverloadedContract":[72]},"nodeType":"SourceUnit","src":"32:483:1","nodes":[{"id":32,"nodeType":"PragmaDirective","src":"32:23:1","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":72,"nodeType":"ContractDefinition","src":"57:457:1","nodes":[{"id":34,"nodeType":"EventDefinition","src":"91:16:1","nodes":[],"anonymous":false,"eventSelector":"3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d","name":"Trigger","nameLocation":"97:7:1","parameters":{"id":33,"nodeType":"ParameterList","parameters":[],"src":"104:2:1"}},{"id":41,"nodeType":"FunctionDefinition","src":"113:45:1","nodes":[],"body":{"id":40,"nodeType":"Block","src":"127:31:1","nodes":[],"statements":[{"eventCall":{"arguments":[],"expression":{"argumentTypes":[],"id":37,"name":"Trigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":34,"src":"142:7:1","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$__$returns$__$","typeString":"function ()"}},"id":38,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"142:9:1","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":39,"nodeType":"EmitStatement","src":"137:14:1"}]},"implemented":true,"kind":"constructor","modifiers":[],"name":"","nameLocation":"-1:-1:-1","parameters":{"id":35,"nodeType":"ParameterList","parameters":[],"src":"124:2:1"},"returnParameters":{"id":36,"nodeType":"ParameterList","parameters":[],"src":"127:0:1"},"scope":72,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":51,"nodeType":"FunctionDefinition","src":"164:132:1","nodes":[],"body":{"id":50,"nodeType":"Block","src":"254:42:1","nodes":[],"statements":[{"expression":{"hexValue":"737472696e67202d3e20737472696e67","id":48,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"271:18:1","typeDescriptions":{"typeIdentifier":"t_stringliteral_a675d5271e48bf44b2d3a2abcbe5392d4a4159912e3d2d332a49139a8b50d538","typeString":"literal_string \"string -> string\""},"value":"string -> string"},"functionReturnParameters":47,"id":49,"nodeType":"Return","src":"264:25:1"}]},"functionSelector":"bc2d73ba","implemented":true,"kind":"function","modifiers":[],"name":"exampleFunction","nameLocation":"173:15:1","parameters":{"id":44,"nodeType":"ParameterList","parameters":[{"constant":false,"id":43,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":51,"src":"198:13:1","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string"},"typeName":{"id":42,"name":"string","nodeType":"ElementaryTypeName","src":"198:6:1","typeDescriptions":{"typeIdentifier":"t_string_storage_ptr","typeString":"string"}},"visibility":"internal"}],"src":"188:29:1"},"returnParameters":{"id":47,"nodeType":"ParameterList","parameters":[{"constant":false,"id":46,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":51,"src":"239:13:1","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string"},"typeName":{"id":45,"name":"string","nodeType":"ElementaryTypeName","src":"239:6:1","typeDescriptions":{"typeIdentifier":"t_string_storage_ptr","typeString":"string"}},"visibility":"internal"}],"src":"238:15:1"},"scope":72,"stateMutability":"pure","virtual":false,"visibility":"public"},{"id":61,"nodeType":"FunctionDefinition","src":"302:113:1","nodes":[],"body":{"id":60,"nodeType":"Block","src":"372:43:1","nodes":[],"statements":[{"expression":{"hexValue":"75696e74323536202d3e20737472696e67","id":58,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"389:19:1","typeDescriptions":{"typeIdentifier":"t_stringliteral_56541f37aba8911ed7b3fc4c5c74297515444b42d7c1b74ff1c1abc66e2d65cd","typeString":"literal_string \"uint256 -> string\""},"value":"uint256 -> string"},"functionReturnParameters":57,"id":59,"nodeType":"Return","src":"382:26:1"}]},"functionSelector":"934bc29d","implemented":true,"kind":"function","modifiers":[],"name":"exampleFunction","nameLocation":"311:15:1","parameters":{"id":54,"nodeType":"ParameterList","parameters":[{"constant":false,"id":53,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":61,"src":"327:7:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":52,"name":"uint256","nodeType":"ElementaryTypeName","src":"327:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"326:9:1"},"returnParameters":{"id":57,"nodeType":"ParameterList","parameters":[{"constant":false,"id":56,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":61,"src":"357:13:1","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string"},"typeName":{"id":55,"name":"string","nodeType":"ElementaryTypeName","src":"357:6:1","typeDescriptions":{"typeIdentifier":"t_string_storage_ptr","typeString":"string"}},"visibility":"internal"}],"src":"356:15:1"},"scope":72,"stateMutability":"pure","virtual":false,"visibility":"public"},{"id":71,"nodeType":"FunctionDefinition","src":"421:91:1","nodes":[],"body":{"id":70,"nodeType":"Block","src":"485:27:1","nodes":[],"statements":[{"expression":{"hexValue":"323536","id":68,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"502:3:1","typeDescriptions":{"typeIdentifier":"t_rational_256_by_1","typeString":"int_const 256"},"value":"256"},"functionReturnParameters":67,"id":69,"nodeType":"Return","src":"495:10:1"}]},"functionSelector":"31870cbc","implemented":true,"kind":"function","modifiers":[],"name":"exampleFunction","nameLocation":"430:15:1","parameters":{"id":64,"nodeType":"ParameterList","parameters":[{"constant":false,"id":63,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":71,"src":"446:7:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"},"typeName":{"id":62,"name":"bytes32","nodeType":"ElementaryTypeName","src":"446:7:1","typeDescriptions":{"typeIdentifier":"t_bytes32","typeString":"bytes32"}},"visibility":"internal"}],"src":"445:9:1"},"returnParameters":{"id":67,"nodeType":"ParameterList","parameters":[{"constant":false,"id":66,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":71,"src":"476:7:1","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":65,"name":"uint256","nodeType":"ElementaryTypeName","src":"476:7:1","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"475:9:1"},"scope":72,"stateMutability":"pure","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"OverloadedContract","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[72],"name":"OverloadedContract","nameLocation":"66:18:1","scope":73,"usedErrors":[]}],"license":"MIT"},"id":1} \ No newline at end of file +{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"function","name":"exampleFunction","inputs":[{"name":"","type":"string","internalType":"string"}],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561000f575f80fd5b507f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d60405160405180910390a16104a4806100495f395ff3fe608060405234801561000f575f80fd5b506004361061003f575f3560e01c806331870cbc14610043578063934bc29d14610073578063bc2d73ba146100a3575b5f80fd5b61005d600480360381019061005891906101a0565b6100d3565b60405161006a91906101e3565b60405180910390f35b61008d60048036038101906100889190610226565b6100de565b60405161009a91906102db565b60405180910390f35b6100bd60048036038101906100b89190610427565b61011d565b6040516100ca91906102db565b60405180910390f35b5f6101009050919050565b60606040518060400160405280601181526020017f75696e74323536202d3e20737472696e670000000000000000000000000000008152509050919050565b60606040518060400160405280601081526020017f737472696e67202d3e20737472696e67000000000000000000000000000000008152509050919050565b5f604051905090565b5f80fd5b5f80fd5b5f819050919050565b61017f8161016d565b8114610189575f80fd5b50565b5f8135905061019a81610176565b92915050565b5f602082840312156101b5576101b4610165565b5b5f6101c28482850161018c565b91505092915050565b5f819050919050565b6101dd816101cb565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b610205816101cb565b811461020f575f80fd5b50565b5f81359050610220816101fc565b92915050565b5f6020828403121561023b5761023a610165565b5b5f61024884828501610212565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b8381101561028857808201518184015260208101905061026d565b5f8484015250505050565b5f601f19601f8301169050919050565b5f6102ad82610251565b6102b7818561025b565b93506102c781856020860161026b565b6102d081610293565b840191505092915050565b5f6020820190508181035f8301526102f381846102a3565b905092915050565b5f80fd5b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b61033982610293565b810181811067ffffffffffffffff8211171561035857610357610303565b5b80604052505050565b5f61036a61015c565b90506103768282610330565b919050565b5f67ffffffffffffffff82111561039557610394610303565b5b61039e82610293565b9050602081019050919050565b828183375f83830152505050565b5f6103cb6103c68461037b565b610361565b9050828152602081018484840111156103e7576103e66102ff565b5b6103f28482856103ab565b509392505050565b5f82601f83011261040e5761040d6102fb565b5b813561041e8482602086016103b9565b91505092915050565b5f6020828403121561043c5761043b610165565b5b5f82013567ffffffffffffffff81111561045957610458610169565b5b610465848285016103fa565b9150509291505056fea2646970667358221220f510af729492328df1260e592035db6462a7a7d948201d9ae530b6258c5cf40364736f6c63430008160033","sourceMap":"57:457:2:-:0;;;113:45;;;;;;;;;;142:9;;;;;;;;;;57:457;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"57:457:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;421:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;302:113;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;164:132;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;421:91;476:7;502:3;495:10;;421:91;;;:::o;302:113::-;357:13;382:26;;;;;;;;;;;;;;;;;;;302:113;;;:::o;164:132::-;239:13;264:25;;;;;;;;;;;;;;;;;;;164:132;;;:::o;7:75:5:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:77::-;1062:7;1091:5;1080:16;;1025:77;;;:::o;1108:118::-;1195:24;1213:5;1195:24;:::i;:::-;1190:3;1183:37;1108:118;;:::o;1232:222::-;1325:4;1363:2;1352:9;1348:18;1340:26;;1376:71;1444:1;1433:9;1429:17;1420:6;1376:71;:::i;:::-;1232:222;;;;:::o;1460:122::-;1533:24;1551:5;1533:24;:::i;:::-;1526:5;1523:35;1513:63;;1572:1;1569;1562:12;1513:63;1460:122;:::o;1588:139::-;1634:5;1672:6;1659:20;1650:29;;1688:33;1715:5;1688:33;:::i;:::-;1588:139;;;;:::o;1733:329::-;1792:6;1841:2;1829:9;1820:7;1816:23;1812:32;1809:119;;;1847:79;;:::i;:::-;1809:119;1967:1;1992:53;2037:7;2028:6;2017:9;2013:22;1992:53;:::i;:::-;1982:63;;1938:117;1733:329;;;;:::o;2068:99::-;2120:6;2154:5;2148:12;2138:22;;2068:99;;;:::o;2173:169::-;2257:11;2291:6;2286:3;2279:19;2331:4;2326:3;2322:14;2307:29;;2173:169;;;;:::o;2348:246::-;2429:1;2439:113;2453:6;2450:1;2447:13;2439:113;;;2538:1;2533:3;2529:11;2523:18;2519:1;2514:3;2510:11;2503:39;2475:2;2472:1;2468:10;2463:15;;2439:113;;;2586:1;2577:6;2572:3;2568:16;2561:27;2410:184;2348:246;;;:::o;2600:102::-;2641:6;2692:2;2688:7;2683:2;2676:5;2672:14;2668:28;2658:38;;2600:102;;;:::o;2708:377::-;2796:3;2824:39;2857:5;2824:39;:::i;:::-;2879:71;2943:6;2938:3;2879:71;:::i;:::-;2872:78;;2959:65;3017:6;3012:3;3005:4;2998:5;2994:16;2959:65;:::i;:::-;3049:29;3071:6;3049:29;:::i;:::-;3044:3;3040:39;3033:46;;2800:285;2708:377;;;;:::o;3091:313::-;3204:4;3242:2;3231:9;3227:18;3219:26;;3291:9;3285:4;3281:20;3277:1;3266:9;3262:17;3255:47;3319:78;3392:4;3383:6;3319:78;:::i;:::-;3311:86;;3091:313;;;;:::o;3410:117::-;3519:1;3516;3509:12;3533:117;3642:1;3639;3632:12;3656:180;3704:77;3701:1;3694:88;3801:4;3798:1;3791:15;3825:4;3822:1;3815:15;3842:281;3925:27;3947:4;3925:27;:::i;:::-;3917:6;3913:40;4055:6;4043:10;4040:22;4019:18;4007:10;4004:34;4001:62;3998:88;;;4066:18;;:::i;:::-;3998:88;4106:10;4102:2;4095:22;3885:238;3842:281;;:::o;4129:129::-;4163:6;4190:20;;:::i;:::-;4180:30;;4219:33;4247:4;4239:6;4219:33;:::i;:::-;4129:129;;;:::o;4264:308::-;4326:4;4416:18;4408:6;4405:30;4402:56;;;4438:18;;:::i;:::-;4402:56;4476:29;4498:6;4476:29;:::i;:::-;4468:37;;4560:4;4554;4550:15;4542:23;;4264:308;;;:::o;4578:146::-;4675:6;4670:3;4665;4652:30;4716:1;4707:6;4702:3;4698:16;4691:27;4578:146;;;:::o;4730:425::-;4808:5;4833:66;4849:49;4891:6;4849:49;:::i;:::-;4833:66;:::i;:::-;4824:75;;4922:6;4915:5;4908:21;4960:4;4953:5;4949:16;4998:3;4989:6;4984:3;4980:16;4977:25;4974:112;;;5005:79;;:::i;:::-;4974:112;5095:54;5142:6;5137:3;5132;5095:54;:::i;:::-;4814:341;4730:425;;;;;:::o;5175:340::-;5231:5;5280:3;5273:4;5265:6;5261:17;5257:27;5247:122;;5288:79;;:::i;:::-;5247:122;5405:6;5392:20;5430:79;5505:3;5497:6;5490:4;5482:6;5478:17;5430:79;:::i;:::-;5421:88;;5237:278;5175:340;;;;:::o;5521:509::-;5590:6;5639:2;5627:9;5618:7;5614:23;5610:32;5607:119;;;5645:79;;:::i;:::-;5607:119;5793:1;5782:9;5778:17;5765:31;5823:18;5815:6;5812:30;5809:117;;;5845:79;;:::i;:::-;5809:117;5950:63;6005:7;5996:6;5985:9;5981:22;5950:63;:::i;:::-;5940:73;;5736:287;5521:509;;;;:::o","linkReferences":{}},"methodIdentifiers":{"exampleFunction(bytes32)":"31870cbc","exampleFunction(string)":"bc2d73ba","exampleFunction(uint256)":"934bc29d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"exampleFunction\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OverloadedContract.sol\":\"OverloadedContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/OverloadedContract.sol\":{\"keccak256\":\"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be\",\"dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]},{"inputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function","name":"exampleFunction","outputs":[{"internalType":"string","name":"","type":"string"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/OverloadedContract.sol":"OverloadedContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/OverloadedContract.sol":{"keccak256":"0xc6734859398f3be8468d6e6c7fd8b03a52243223799ce17d5e4ab9d9aca1fc45","urls":["bzz-raw://2c860b9cd7d0a2086e164ce38a2aa24a5b7f681bb575a5a656f732d3742761be","dweb:/ipfs/QmPwazDSTPrNpVrRY2vunso7VXunWp5dn1641TzxK9eZfe"],"license":"MIT"}},"version":1},"id":2} \ No newline at end of file diff --git a/tests/contracts/out/RevertingContract.sol/RevertingContract.json b/tests/contracts/out/RevertingContract.sol/RevertingContract.json index 4c447a28729..3fd74e0aa28 100644 --- a/tests/contracts/out/RevertingContract.sol/RevertingContract.json +++ b/tests/contracts/out/RevertingContract.sol/RevertingContract.json @@ -1 +1 @@ -{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561001057600080fd5b506040517f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d90600090a1610120806100496000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea2646970667358221220ad875f460a402063be4ff63412a90d65fa24398c907d52e2a0926375442cb6f064736f6c63430008130033","sourceMap":"57:259:2:-:0;;;112:45;;;;;;;;;-1:-1:-1;141:9:2;;;;;;;57:259;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x6080604052348015600f57600080fd5b506004361060285760003560e01c8063812600df14602d575b600080fd5b603c603836600460b2565b604e565b60405190815260200160405180910390f35b6000600a821060a35760405162461bcd60e51b815260206004820152601b60248201527f63616e206f6e6c792068616e646c652076616c756573203c2031300000000000604482015260640160405180910390fd5b60ac82600160ca565b92915050565b60006020828403121560c357600080fd5b5035919050565b8082018082111560ac57634e487b7160e01b600052601160045260246000fdfea2646970667358221220ad875f460a402063be4ff63412a90d65fa24398c907d52e2a0926375442cb6f064736f6c63430008130033","sourceMap":"57:259:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;163:151;;;;;;:::i;:::-;;:::i;:::-;;;345:25:4;;;333:2;318:18;163:151:2;;;;;;;;212:7;247:2;239:5;:10;231:50;;;;-1:-1:-1;;;231:50:2;;583:2:4;231:50:2;;;565:21:4;622:2;602:18;;;595:30;661:29;641:18;;;634:57;708:18;;231:50:2;;;;;;;;298:9;:5;306:1;298:9;:::i;:::-;291:16;163:151;-1:-1:-1;;163:151:2:o;14:180:4:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:4;;14:180;-1:-1:-1;14:180:4:o;737:222::-;802:9;;;823:10;;;820:133;;;875:10;870:3;866:20;863:1;856:31;910:4;907:1;900:15;938:4;935:1;928:15","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/RevertingContract.sol\":\"RevertingContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/RevertingContract.sol\":{\"keccak256\":\"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b\",\"dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.19+commit.7dd6d404"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/RevertingContract.sol":"RevertingContract"},"evmVersion":"paris","libraries":{}},"sources":{"src/RevertingContract.sol":{"keccak256":"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23","urls":["bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b","dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb"],"license":"MIT"}},"version":1},"ast":{"absolutePath":"src/RevertingContract.sol","id":104,"exportedSymbols":{"RevertingContract":[103]},"nodeType":"SourceUnit","src":"32:285:2","nodes":[{"id":74,"nodeType":"PragmaDirective","src":"32:23:2","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":103,"nodeType":"ContractDefinition","src":"57:259:2","nodes":[{"id":76,"nodeType":"EventDefinition","src":"90:16:2","nodes":[],"anonymous":false,"eventSelector":"3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d","name":"Trigger","nameLocation":"96:7:2","parameters":{"id":75,"nodeType":"ParameterList","parameters":[],"src":"103:2:2"}},{"id":83,"nodeType":"FunctionDefinition","src":"112:45:2","nodes":[],"body":{"id":82,"nodeType":"Block","src":"126:31:2","nodes":[],"statements":[{"eventCall":{"arguments":[],"expression":{"argumentTypes":[],"id":79,"name":"Trigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":76,"src":"141:7:2","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$__$returns$__$","typeString":"function ()"}},"id":80,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"141:9:2","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":81,"nodeType":"EmitStatement","src":"136:14:2"}]},"implemented":true,"kind":"constructor","modifiers":[],"name":"","nameLocation":"-1:-1:-1","parameters":{"id":77,"nodeType":"ParameterList","parameters":[],"src":"123:2:2"},"returnParameters":{"id":78,"nodeType":"ParameterList","parameters":[],"src":"126:0:2"},"scope":103,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":102,"nodeType":"FunctionDefinition","src":"163:151:2","nodes":[],"body":{"id":101,"nodeType":"Block","src":"221:93:2","nodes":[],"statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":93,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":91,"name":"value","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":85,"src":"239:5:2","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"<","rightExpression":{"hexValue":"3130","id":92,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"247:2:2","typeDescriptions":{"typeIdentifier":"t_rational_10_by_1","typeString":"int_const 10"},"value":"10"},"src":"239:10:2","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"63616e206f6e6c792068616e646c652076616c756573203c203130","id":94,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"251:29:2","typeDescriptions":{"typeIdentifier":"t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449","typeString":"literal_string \"can only handle values < 10\""},"value":"can only handle values < 10"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_578cd1fc098748633f5d7d46bba428bb3129c1e63324f2b7151699cae5146449","typeString":"literal_string \"can only handle values < 10\""}],"id":90,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"231:7:2","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":95,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"231:50:2","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":96,"nodeType":"ExpressionStatement","src":"231:50:2"},{"expression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":99,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":97,"name":"value","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":85,"src":"298:5:2","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"31","id":98,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"306:1:2","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"src":"298:9:2","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"functionReturnParameters":89,"id":100,"nodeType":"Return","src":"291:16:2"}]},"functionSelector":"812600df","implemented":true,"kind":"function","modifiers":[],"name":"inc","nameLocation":"172:3:2","parameters":{"id":86,"nodeType":"ParameterList","parameters":[{"constant":false,"id":85,"mutability":"mutable","name":"value","nameLocation":"184:5:2","nodeType":"VariableDeclaration","scope":102,"src":"176:13:2","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":84,"name":"uint256","nodeType":"ElementaryTypeName","src":"176:7:2","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"175:15:2"},"returnParameters":{"id":89,"nodeType":"ParameterList","parameters":[{"constant":false,"id":88,"mutability":"mutable","name":"","nameLocation":"-1:-1:-1","nodeType":"VariableDeclaration","scope":102,"src":"212:7:2","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":87,"name":"uint256","nodeType":"ElementaryTypeName","src":"212:7:2","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"211:9:2"},"scope":103,"stateMutability":"pure","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"RevertingContract","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[103],"name":"RevertingContract","nameLocation":"66:17:2","scope":104,"usedErrors":[]}],"license":"MIT"},"id":2} \ No newline at end of file +{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"inc","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"type":"event","name":"Trigger","inputs":[],"anonymous":false}],"bytecode":{"object":"0x608060405234801561000f575f80fd5b507f3d53a39550e04688065827f3bb86584cb007ab9ebca7ebd528e7301c9c31eb5d60405160405180910390a161024d806100495f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea26469706673582212201d5be3aca99e1d2430eee51090e4c236bedcc30e14391ebad9ca024d7255f6e464736f6c63430008160033","sourceMap":"57:259:3:-:0;;;112:45;;;;;;;;;;141:9;;;;;;;;;;57:259;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063812600df1461002d575b5f80fd5b610047600480360381019061004291906100ec565b61005d565b6040516100549190610126565b60405180910390f35b5f600a82106100a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161009890610199565b60405180910390fd5b6001826100ae91906101e4565b9050919050565b5f80fd5b5f819050919050565b6100cb816100b9565b81146100d5575f80fd5b50565b5f813590506100e6816100c2565b92915050565b5f60208284031215610101576101006100b5565b5b5f61010e848285016100d8565b91505092915050565b610120816100b9565b82525050565b5f6020820190506101395f830184610117565b92915050565b5f82825260208201905092915050565b7f63616e206f6e6c792068616e646c652076616c756573203c20313000000000005f82015250565b5f610183601b8361013f565b915061018e8261014f565b602082019050919050565b5f6020820190508181035f8301526101b081610177565b9050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f6101ee826100b9565b91506101f9836100b9565b9250828201905080821115610211576102106101b7565b5b9291505056fea26469706673582212201d5be3aca99e1d2430eee51090e4c236bedcc30e14391ebad9ca024d7255f6e464736f6c63430008160033","sourceMap":"57:259:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;163:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;212:7;247:2;239:5;:10;231:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;306:1;298:5;:9;;;;:::i;:::-;291:16;;163:151;;;:::o;88:117:5:-;197:1;194;187:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:118::-;1112:24;1130:5;1112:24;:::i;:::-;1107:3;1100:37;1025:118;;:::o;1149:222::-;1242:4;1280:2;1269:9;1265:18;1257:26;;1293:71;1361:1;1350:9;1346:17;1337:6;1293:71;:::i;:::-;1149:222;;;;:::o;1377:169::-;1461:11;1495:6;1490:3;1483:19;1535:4;1530:3;1526:14;1511:29;;1377:169;;;;:::o;1552:177::-;1692:29;1688:1;1680:6;1676:14;1669:53;1552:177;:::o;1735:366::-;1877:3;1898:67;1962:2;1957:3;1898:67;:::i;:::-;1891:74;;1974:93;2063:3;1974:93;:::i;:::-;2092:2;2087:3;2083:12;2076:19;;1735:366;;;:::o;2107:419::-;2273:4;2311:2;2300:9;2296:18;2288:26;;2360:9;2354:4;2350:20;2346:1;2335:9;2331:17;2324:47;2388:131;2514:4;2388:131;:::i;:::-;2380:139;;2107:419;;;:::o;2532:180::-;2580:77;2577:1;2570:88;2677:4;2674:1;2667:15;2701:4;2698:1;2691:15;2718:191;2758:3;2777:20;2795:1;2777:20;:::i;:::-;2772:25;;2811:20;2829:1;2811:20;:::i;:::-;2806:25;;2854:1;2851;2847:9;2840:16;;2875:3;2872:1;2869:10;2866:36;;;2882:18;;:::i;:::-;2866:36;2718:191;;;;:::o","linkReferences":{}},"methodIdentifiers":{"inc(uint256)":"812600df"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"inc\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/RevertingContract.sol\":\"RevertingContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/RevertingContract.sol\":{\"keccak256\":\"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b\",\"dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"pure","type":"function","name":"inc","outputs":[{"internalType":"uint256","name":"","type":"uint256"}]}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/RevertingContract.sol":"RevertingContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/RevertingContract.sol":{"keccak256":"0xb0ccab460539f08d5f40044fee3e45c26590431d6d08734acde070ca01d84e23","urls":["bzz-raw://3cece4cf2b0d867fb8ef474375f8907df5412056773e20e804e12061d98d057b","dweb:/ipfs/QmeLfvzWjkpA6mCt1FJyNvgKeugzJJTRSBdyDUSBCovyrb"],"license":"MIT"}},"version":1},"id":3} \ No newline at end of file diff --git a/tests/contracts/out/SimpleContract.sol/SimpleContract.json b/tests/contracts/out/SimpleContract.sol/SimpleContract.json index 57eb93d7eee..21deecd6fe9 100644 --- a/tests/contracts/out/SimpleContract.sol/SimpleContract.json +++ b/tests/contracts/out/SimpleContract.sol/SimpleContract.json @@ -1 +1 @@ -{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitAnotherTrigger","inputs":[{"name":"a","type":"uint256","internalType":"uint256"},{"name":"b","type":"uint256","internalType":"uint256"},{"name":"c","type":"uint256","internalType":"uint256"},{"name":"data","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitTrigger","inputs":[{"name":"x","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"AnotherTrigger","inputs":[{"name":"a","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"b","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"c","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"data","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"type":"event","name":"Trigger","inputs":[{"name":"x","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false}],"bytecode":{"object":"0x608060405234801561001057600080fd5b50604051600081527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a1610270806100546000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806316d04e0d1461003b578063931919ea14610050575b600080fd5b61004e6100493660046100dd565b610063565b005b61004e61005e36600461011e565b61009d565b60405161ffff821681527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a150565b8183857f2cb351db58390c313534745d80b5f0abff9230502a6374a97b9caa76b31c5d8a846040516100cf91906101ec565b60405180910390a450505050565b6000602082840312156100ef57600080fd5b813561ffff8116811461010157600080fd5b9392505050565b634e487b7160e01b600052604160045260246000fd5b6000806000806080858703121561013457600080fd5b843593506020850135925060408501359150606085013567ffffffffffffffff8082111561016157600080fd5b818701915087601f83011261017557600080fd5b81358181111561018757610187610108565b604051601f8201601f19908116603f011681019083821181831017156101af576101af610108565b816040528281528a60208487010111156101c857600080fd5b82602086016020830137600060208483010152809550505050505092959194509250565b600060208083528351808285015260005b81811015610219578581018301518582016040015282016101fd565b506000604082860101526040601f19601f830116850101925050509291505056fea264697066735822122051969b527a63ab67686e528eb2de0bd24f1a84835193586c0318cfb81b2cb0ac64736f6c63430008130033","sourceMap":"57:596:3:-:0;;;308:46;;;;;;;;;-1:-1:-1;337:10:3;;345:1;167:38:4;;337:10:3;;155:2:4;140:18;337:10:3;;;;;;;57:596;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561001057600080fd5b50600436106100365760003560e01c806316d04e0d1461003b578063931919ea14610050575b600080fd5b61004e6100493660046100dd565b610063565b005b61004e61005e36600461011e565b61009d565b60405161ffff821681527f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5449060200160405180910390a150565b8183857f2cb351db58390c313534745d80b5f0abff9230502a6374a97b9caa76b31c5d8a846040516100cf91906101ec565b60405180910390a450505050565b6000602082840312156100ef57600080fd5b813561ffff8116811461010157600080fd5b9392505050565b634e487b7160e01b600052604160045260246000fd5b6000806000806080858703121561013457600080fd5b843593506020850135925060408501359150606085013567ffffffffffffffff8082111561016157600080fd5b818701915087601f83011261017557600080fd5b81358181111561018757610187610108565b604051601f8201601f19908116603f011681019083821181831017156101af576101af610108565b816040528281528a60208487010111156101c857600080fd5b82602086016020830137600060208483010152809550505050505092959194509250565b600060208083528351808285015260005b81811015610219578581018301518582016040015282016101fd565b506000604082860101526040601f19601f830116850101925050509291505056fea264697066735822122051969b527a63ab67686e528eb2de0bd24f1a84835193586c0318cfb81b2cb0ac64736f6c63430008130033","sourceMap":"57:596:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;360:70;;;;;;:::i;:::-;;:::i;:::-;;474:177;;;;;;:::i;:::-;;:::i;360:70::-;413:10;;1729:6:4;1717:19;;1699:38;;413:10:3;;1687:2:4;1672:18;413:10:3;;;;;;;360:70;:::o;474:177::-;636:1;633;630;615:29;639:4;615:29;;;;;;:::i;:::-;;;;;;;;474:177;;;;:::o;14:272:4:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;230:6;223:5;219:18;212:5;209:29;199:57;;252:1;249;242:12;199:57;275:5;14:272;-1:-1:-1;;;14:272:4:o;291:127::-;352:10;347:3;343:20;340:1;333:31;383:4;380:1;373:15;407:4;404:1;397:15;423:1127;519:6;527;535;543;596:3;584:9;575:7;571:23;567:33;564:53;;;613:1;610;603:12;564:53;649:9;636:23;626:33;;706:2;695:9;691:18;678:32;668:42;;757:2;746:9;742:18;729:32;719:42;;812:2;801:9;797:18;784:32;835:18;876:2;868:6;865:14;862:34;;;892:1;889;882:12;862:34;930:6;919:9;915:22;905:32;;975:7;968:4;964:2;960:13;956:27;946:55;;997:1;994;987:12;946:55;1033:2;1020:16;1055:2;1051;1048:10;1045:36;;;1061:18;;:::i;:::-;1136:2;1130:9;1104:2;1190:13;;-1:-1:-1;;1186:22:4;;;1210:2;1182:31;1178:40;1166:53;;;1234:18;;;1254:22;;;1231:46;1228:72;;;1280:18;;:::i;:::-;1320:10;1316:2;1309:22;1355:2;1347:6;1340:18;1395:7;1390:2;1385;1381;1377:11;1373:20;1370:33;1367:53;;;1416:1;1413;1406:12;1367:53;1472:2;1467;1463;1459:11;1454:2;1446:6;1442:15;1429:46;1517:1;1512:2;1507;1499:6;1495:15;1491:24;1484:35;1538:6;1528:16;;;;;;;423:1127;;;;;;;:::o;1748:548::-;1860:4;1889:2;1918;1907:9;1900:21;1950:6;1944:13;1993:6;1988:2;1977:9;1973:18;1966:34;2018:1;2028:140;2042:6;2039:1;2036:13;2028:140;;;2137:14;;;2133:23;;2127:30;2103:17;;;2122:2;2099:26;2092:66;2057:10;;2028:140;;;2032:3;2217:1;2212:2;2203:6;2192:9;2188:22;2184:31;2177:42;2287:2;2280;2276:7;2271:2;2263:6;2259:15;2255:29;2244:9;2240:45;2236:54;2228:62;;;;1748:548;;;;:::o","linkReferences":{}},"methodIdentifiers":{"emitAnotherTrigger(uint256,uint256,uint256,string)":"931919ea","emitTrigger(uint16)":"16d04e0d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.19+commit.7dd6d404\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"AnotherTrigger\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"emitAnotherTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"emitTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/SimpleContract.sol\":\"SimpleContract\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/SimpleContract.sol\":{\"keccak256\":\"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d\",\"dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.19+commit.7dd6d404"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256","indexed":true},{"internalType":"uint256","name":"b","type":"uint256","indexed":true},{"internalType":"uint256","name":"c","type":"uint256","indexed":true},{"internalType":"string","name":"data","type":"string","indexed":false}],"type":"event","name":"AnotherTrigger","anonymous":false},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16","indexed":false}],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"},{"internalType":"string","name":"data","type":"string"}],"stateMutability":"nonpayable","type":"function","name":"emitAnotherTrigger"},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16"}],"stateMutability":"nonpayable","type":"function","name":"emitTrigger"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":true,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/SimpleContract.sol":"SimpleContract"},"evmVersion":"paris","libraries":{}},"sources":{"src/SimpleContract.sol":{"keccak256":"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0","urls":["bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d","dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF"],"license":"MIT"}},"version":1},"ast":{"absolutePath":"src/SimpleContract.sol","id":158,"exportedSymbols":{"SimpleContract":[157]},"nodeType":"SourceUnit","src":"32:622:3","nodes":[{"id":105,"nodeType":"PragmaDirective","src":"32:23:3","nodes":[],"literals":["solidity","^","0.8",".0"]},{"id":157,"nodeType":"ContractDefinition","src":"57:596:3","nodes":[{"id":109,"nodeType":"EventDefinition","src":"87:24:3","nodes":[],"anonymous":false,"eventSelector":"166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b544","name":"Trigger","nameLocation":"93:7:3","parameters":{"id":108,"nodeType":"ParameterList","parameters":[{"constant":false,"id":107,"indexed":false,"mutability":"mutable","name":"x","nameLocation":"108:1:3","nodeType":"VariableDeclaration","scope":109,"src":"101:8:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint16","typeString":"uint16"},"typeName":{"id":106,"name":"uint16","nodeType":"ElementaryTypeName","src":"101:6:3","typeDescriptions":{"typeIdentifier":"t_uint16","typeString":"uint16"}},"visibility":"internal"}],"src":"100:10:3"}},{"id":119,"nodeType":"EventDefinition","src":"173:129:3","nodes":[],"anonymous":false,"eventSelector":"2cb351db58390c313534745d80b5f0abff9230502a6374a97b9caa76b31c5d8a","name":"AnotherTrigger","nameLocation":"179:14:3","parameters":{"id":118,"nodeType":"ParameterList","parameters":[{"constant":false,"id":111,"indexed":true,"mutability":"mutable","name":"a","nameLocation":"219:1:3","nodeType":"VariableDeclaration","scope":119,"src":"203:17:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":110,"name":"uint256","nodeType":"ElementaryTypeName","src":"203:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":113,"indexed":true,"mutability":"mutable","name":"b","nameLocation":"246:1:3","nodeType":"VariableDeclaration","scope":119,"src":"230:17:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":112,"name":"uint256","nodeType":"ElementaryTypeName","src":"230:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":115,"indexed":true,"mutability":"mutable","name":"c","nameLocation":"273:1:3","nodeType":"VariableDeclaration","scope":119,"src":"257:17:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":114,"name":"uint256","nodeType":"ElementaryTypeName","src":"257:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":117,"indexed":false,"mutability":"mutable","name":"data","nameLocation":"291:4:3","nodeType":"VariableDeclaration","scope":119,"src":"284:11:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string"},"typeName":{"id":116,"name":"string","nodeType":"ElementaryTypeName","src":"284:6:3","typeDescriptions":{"typeIdentifier":"t_string_storage_ptr","typeString":"string"}},"visibility":"internal"}],"src":"193:108:3"}},{"id":127,"nodeType":"FunctionDefinition","src":"308:46:3","nodes":[],"body":{"id":126,"nodeType":"Block","src":"322:32:3","nodes":[],"statements":[{"eventCall":{"arguments":[{"hexValue":"30","id":123,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"345:1:3","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":122,"name":"Trigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":109,"src":"337:7:3","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$_t_uint16_$returns$__$","typeString":"function (uint16)"}},"id":124,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"337:10:3","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":125,"nodeType":"EmitStatement","src":"332:15:3"}]},"implemented":true,"kind":"constructor","modifiers":[],"name":"","nameLocation":"-1:-1:-1","parameters":{"id":120,"nodeType":"ParameterList","parameters":[],"src":"319:2:3"},"returnParameters":{"id":121,"nodeType":"ParameterList","parameters":[],"src":"322:0:3"},"scope":157,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":137,"nodeType":"FunctionDefinition","src":"360:70:3","nodes":[],"body":{"id":136,"nodeType":"Block","src":"398:32:3","nodes":[],"statements":[{"eventCall":{"arguments":[{"id":133,"name":"x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":129,"src":"421:1:3","typeDescriptions":{"typeIdentifier":"t_uint16","typeString":"uint16"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint16","typeString":"uint16"}],"id":132,"name":"Trigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":109,"src":"413:7:3","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$_t_uint16_$returns$__$","typeString":"function (uint16)"}},"id":134,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"413:10:3","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":135,"nodeType":"EmitStatement","src":"408:15:3"}]},"functionSelector":"16d04e0d","implemented":true,"kind":"function","modifiers":[],"name":"emitTrigger","nameLocation":"369:11:3","parameters":{"id":130,"nodeType":"ParameterList","parameters":[{"constant":false,"id":129,"mutability":"mutable","name":"x","nameLocation":"388:1:3","nodeType":"VariableDeclaration","scope":137,"src":"381:8:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint16","typeString":"uint16"},"typeName":{"id":128,"name":"uint16","nodeType":"ElementaryTypeName","src":"381:6:3","typeDescriptions":{"typeIdentifier":"t_uint16","typeString":"uint16"}},"visibility":"internal"}],"src":"380:10:3"},"returnParameters":{"id":131,"nodeType":"ParameterList","parameters":[],"src":"398:0:3"},"scope":157,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":156,"nodeType":"FunctionDefinition","src":"474:177:3","nodes":[],"body":{"id":155,"nodeType":"Block","src":"600:51:3","nodes":[],"statements":[{"eventCall":{"arguments":[{"id":149,"name":"a","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":139,"src":"630:1:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"id":150,"name":"b","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":141,"src":"633:1:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"id":151,"name":"c","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":143,"src":"636:1:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"id":152,"name":"data","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":145,"src":"639:4:3","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_string_memory_ptr","typeString":"string memory"}],"id":148,"name":"AnotherTrigger","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":119,"src":"615:14:3","typeDescriptions":{"typeIdentifier":"t_function_event_nonpayable$_t_uint256_$_t_uint256_$_t_uint256_$_t_string_memory_ptr_$returns$__$","typeString":"function (uint256,uint256,uint256,string memory)"}},"id":153,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"nameLocations":[],"names":[],"nodeType":"FunctionCall","src":"615:29:3","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":154,"nodeType":"EmitStatement","src":"610:34:3"}]},"functionSelector":"931919ea","implemented":true,"kind":"function","modifiers":[],"name":"emitAnotherTrigger","nameLocation":"483:18:3","parameters":{"id":146,"nodeType":"ParameterList","parameters":[{"constant":false,"id":139,"mutability":"mutable","name":"a","nameLocation":"519:1:3","nodeType":"VariableDeclaration","scope":156,"src":"511:9:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":138,"name":"uint256","nodeType":"ElementaryTypeName","src":"511:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":141,"mutability":"mutable","name":"b","nameLocation":"538:1:3","nodeType":"VariableDeclaration","scope":156,"src":"530:9:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":140,"name":"uint256","nodeType":"ElementaryTypeName","src":"530:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":143,"mutability":"mutable","name":"c","nameLocation":"557:1:3","nodeType":"VariableDeclaration","scope":156,"src":"549:9:3","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":142,"name":"uint256","nodeType":"ElementaryTypeName","src":"549:7:3","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":145,"mutability":"mutable","name":"data","nameLocation":"582:4:3","nodeType":"VariableDeclaration","scope":156,"src":"568:18:3","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_string_memory_ptr","typeString":"string"},"typeName":{"id":144,"name":"string","nodeType":"ElementaryTypeName","src":"568:6:3","typeDescriptions":{"typeIdentifier":"t_string_storage_ptr","typeString":"string"}},"visibility":"internal"}],"src":"501:91:3"},"returnParameters":{"id":147,"nodeType":"ParameterList","parameters":[],"src":"600:0:3"},"scope":157,"stateMutability":"nonpayable","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"canonicalName":"SimpleContract","contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[157],"name":"SimpleContract","nameLocation":"66:14:3","scope":158,"usedErrors":[]}],"license":"MIT"},"id":3} \ No newline at end of file +{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitAnotherTrigger","inputs":[{"name":"a","type":"uint256","internalType":"uint256"},{"name":"b","type":"uint256","internalType":"uint256"},{"name":"c","type":"uint256","internalType":"uint256"},{"name":"data","type":"string","internalType":"string"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"function","name":"emitTrigger","inputs":[{"name":"x","type":"uint16","internalType":"uint16"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"event","name":"AnotherTrigger","inputs":[{"name":"a","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"b","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"c","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"data","type":"string","indexed":false,"internalType":"string"}],"anonymous":false},{"type":"event","name":"Trigger","inputs":[{"name":"x","type":"uint16","indexed":false,"internalType":"uint16"}],"anonymous":false}],"bytecode":{"object":"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","sourceMap":"57:596:4:-:0;;;308:46;;;;;;;;;;337:10;345:1;337:10;;;;;;:::i;:::-;;;;;;;;57:596;;7:85:5;52:7;81:5;70:16;;7:85;;;:::o;98:89::-;134:7;174:6;167:5;163:18;152:29;;98:89;;;:::o;193:60::-;221:3;242:5;235:12;;193:60;;;:::o;259:156::-;316:9;349:60;366:42;375:32;401:5;375:32;:::i;:::-;366:42;:::i;:::-;349:60;:::i;:::-;336:73;;259:156;;;:::o;421:145::-;515:44;553:5;515:44;:::i;:::-;510:3;503:57;421:145;;:::o;572:236::-;672:4;710:2;699:9;695:18;687:26;;723:78;798:1;787:9;783:17;774:6;723:78;:::i;:::-;572:236;;;;:::o;57:596:4:-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b5060043610610034575f3560e01c806316d04e0d14610038578063931919ea14610054575b5f80fd5b610052600480360381019061004d9190610132565b610070565b005b61006e600480360381019061006991906102cc565b6100aa565b005b7f166a7d625edff952ff346d1bca4edef10254353f72916b7fb072d55d0f97b5448160405161009f919061035b565b60405180910390a150565b8183857f2cb351db58390c313534745d80b5f0abff9230502a6374a97b9caa76b31c5d8a846040516100dc91906103ee565b60405180910390a450505050565b5f604051905090565b5f80fd5b5f80fd5b5f61ffff82169050919050565b610111816100fb565b811461011b575f80fd5b50565b5f8135905061012c81610108565b92915050565b5f60208284031215610147576101466100f3565b5b5f6101548482850161011e565b91505092915050565b5f819050919050565b61016f8161015d565b8114610179575f80fd5b50565b5f8135905061018a81610166565b92915050565b5f80fd5b5f80fd5b5f601f19601f8301169050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b6101de82610198565b810181811067ffffffffffffffff821117156101fd576101fc6101a8565b5b80604052505050565b5f61020f6100ea565b905061021b82826101d5565b919050565b5f67ffffffffffffffff82111561023a576102396101a8565b5b61024382610198565b9050602081019050919050565b828183375f83830152505050565b5f61027061026b84610220565b610206565b90508281526020810184848401111561028c5761028b610194565b5b610297848285610250565b509392505050565b5f82601f8301126102b3576102b2610190565b5b81356102c384826020860161025e565b91505092915050565b5f805f80608085870312156102e4576102e36100f3565b5b5f6102f18782880161017c565b94505060206103028782880161017c565b93505060406103138782880161017c565b925050606085013567ffffffffffffffff811115610334576103336100f7565b5b6103408782880161029f565b91505092959194509250565b610355816100fb565b82525050565b5f60208201905061036e5f83018461034c565b92915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b838110156103ab578082015181840152602081019050610390565b5f8484015250505050565b5f6103c082610374565b6103ca818561037e565b93506103da81856020860161038e565b6103e381610198565b840191505092915050565b5f6020820190508181035f83015261040681846103b6565b90509291505056fea26469706673582212205b9d5c9f3daed1380f46af090eeea4bddb8d6bb8cfa6bcdc5d5544743c72b3a164736f6c63430008160033","sourceMap":"57:596:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;360:70;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;474:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;360:70;413:10;421:1;413:10;;;;;;:::i;:::-;;;;;;;;360:70;:::o;474:177::-;636:1;633;630;615:29;639:4;615:29;;;;;;:::i;:::-;;;;;;;;474:177;;;;:::o;7:75:5:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:89;370:7;410:6;403:5;399:18;388:29;;334:89;;;:::o;429:120::-;501:23;518:5;501:23;:::i;:::-;494:5;491:34;481:62;;539:1;536;529:12;481:62;429:120;:::o;555:137::-;600:5;638:6;625:20;616:29;;654:32;680:5;654:32;:::i;:::-;555:137;;;;:::o;698:327::-;756:6;805:2;793:9;784:7;780:23;776:32;773:119;;;811:79;;:::i;:::-;773:119;931:1;956:52;1000:7;991:6;980:9;976:22;956:52;:::i;:::-;946:62;;902:116;698:327;;;;:::o;1031:77::-;1068:7;1097:5;1086:16;;1031:77;;;:::o;1114:122::-;1187:24;1205:5;1187:24;:::i;:::-;1180:5;1177:35;1167:63;;1226:1;1223;1216:12;1167:63;1114:122;:::o;1242:139::-;1288:5;1326:6;1313:20;1304:29;;1342:33;1369:5;1342:33;:::i;:::-;1242:139;;;;:::o;1387:117::-;1496:1;1493;1486:12;1510:117;1619:1;1616;1609:12;1633:102;1674:6;1725:2;1721:7;1716:2;1709:5;1705:14;1701:28;1691:38;;1633:102;;;:::o;1741:180::-;1789:77;1786:1;1779:88;1886:4;1883:1;1876:15;1910:4;1907:1;1900:15;1927:281;2010:27;2032:4;2010:27;:::i;:::-;2002:6;1998:40;2140:6;2128:10;2125:22;2104:18;2092:10;2089:34;2086:62;2083:88;;;2151:18;;:::i;:::-;2083:88;2191:10;2187:2;2180:22;1970:238;1927:281;;:::o;2214:129::-;2248:6;2275:20;;:::i;:::-;2265:30;;2304:33;2332:4;2324:6;2304:33;:::i;:::-;2214:129;;;:::o;2349:308::-;2411:4;2501:18;2493:6;2490:30;2487:56;;;2523:18;;:::i;:::-;2487:56;2561:29;2583:6;2561:29;:::i;:::-;2553:37;;2645:4;2639;2635:15;2627:23;;2349:308;;;:::o;2663:146::-;2760:6;2755:3;2750;2737:30;2801:1;2792:6;2787:3;2783:16;2776:27;2663:146;;;:::o;2815:425::-;2893:5;2918:66;2934:49;2976:6;2934:49;:::i;:::-;2918:66;:::i;:::-;2909:75;;3007:6;3000:5;2993:21;3045:4;3038:5;3034:16;3083:3;3074:6;3069:3;3065:16;3062:25;3059:112;;;3090:79;;:::i;:::-;3059:112;3180:54;3227:6;3222:3;3217;3180:54;:::i;:::-;2899:341;2815:425;;;;;:::o;3260:340::-;3316:5;3365:3;3358:4;3350:6;3346:17;3342:27;3332:122;;3373:79;;:::i;:::-;3332:122;3490:6;3477:20;3515:79;3590:3;3582:6;3575:4;3567:6;3563:17;3515:79;:::i;:::-;3506:88;;3322:278;3260:340;;;;:::o;3606:945::-;3702:6;3710;3718;3726;3775:3;3763:9;3754:7;3750:23;3746:33;3743:120;;;3782:79;;:::i;:::-;3743:120;3902:1;3927:53;3972:7;3963:6;3952:9;3948:22;3927:53;:::i;:::-;3917:63;;3873:117;4029:2;4055:53;4100:7;4091:6;4080:9;4076:22;4055:53;:::i;:::-;4045:63;;4000:118;4157:2;4183:53;4228:7;4219:6;4208:9;4204:22;4183:53;:::i;:::-;4173:63;;4128:118;4313:2;4302:9;4298:18;4285:32;4344:18;4336:6;4333:30;4330:117;;;4366:79;;:::i;:::-;4330:117;4471:63;4526:7;4517:6;4506:9;4502:22;4471:63;:::i;:::-;4461:73;;4256:288;3606:945;;;;;;;:::o;4557:115::-;4642:23;4659:5;4642:23;:::i;:::-;4637:3;4630:36;4557:115;;:::o;4678:218::-;4769:4;4807:2;4796:9;4792:18;4784:26;;4820:69;4886:1;4875:9;4871:17;4862:6;4820:69;:::i;:::-;4678:218;;;;:::o;4902:99::-;4954:6;4988:5;4982:12;4972:22;;4902:99;;;:::o;5007:169::-;5091:11;5125:6;5120:3;5113:19;5165:4;5160:3;5156:14;5141:29;;5007:169;;;;:::o;5182:246::-;5263:1;5273:113;5287:6;5284:1;5281:13;5273:113;;;5372:1;5367:3;5363:11;5357:18;5353:1;5348:3;5344:11;5337:39;5309:2;5306:1;5302:10;5297:15;;5273:113;;;5420:1;5411:6;5406:3;5402:16;5395:27;5244:184;5182:246;;;:::o;5434:377::-;5522:3;5550:39;5583:5;5550:39;:::i;:::-;5605:71;5669:6;5664:3;5605:71;:::i;:::-;5598:78;;5685:65;5743:6;5738:3;5731:4;5724:5;5720:16;5685:65;:::i;:::-;5775:29;5797:6;5775:29;:::i;:::-;5770:3;5766:39;5759:46;;5526:285;5434:377;;;;:::o;5817:313::-;5930:4;5968:2;5957:9;5953:18;5945:26;;6017:9;6011:4;6007:20;6003:1;5992:9;5988:17;5981:47;6045:78;6118:4;6109:6;6045:78;:::i;:::-;6037:86;;5817:313;;;;:::o","linkReferences":{}},"methodIdentifiers":{"emitAnotherTrigger(uint256,uint256,uint256,string)":"931919ea","emitTrigger(uint16)":"16d04e0d"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.22+commit.4fc1097e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"AnotherTrigger\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"Trigger\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"emitAnotherTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"x\",\"type\":\"uint16\"}],\"name\":\"emitTrigger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/SimpleContract.sol\":\"SimpleContract\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"src/SimpleContract.sol\":{\"keccak256\":\"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d\",\"dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.22+commit.4fc1097e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256","indexed":true},{"internalType":"uint256","name":"b","type":"uint256","indexed":true},{"internalType":"uint256","name":"c","type":"uint256","indexed":true},{"internalType":"string","name":"data","type":"string","indexed":false}],"type":"event","name":"AnotherTrigger","anonymous":false},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16","indexed":false}],"type":"event","name":"Trigger","anonymous":false},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"},{"internalType":"string","name":"data","type":"string"}],"stateMutability":"nonpayable","type":"function","name":"emitAnotherTrigger"},{"inputs":[{"internalType":"uint16","name":"x","type":"uint16"}],"stateMutability":"nonpayable","type":"function","name":"emitTrigger"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":[],"optimizer":{"enabled":false,"runs":200},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/SimpleContract.sol":"SimpleContract"},"evmVersion":"shanghai","libraries":{}},"sources":{"src/SimpleContract.sol":{"keccak256":"0xda954fc2eb36f5f3658f71e59fdb487c6f8947efa45e5e3fb7038c7faff99de0","urls":["bzz-raw://e8253c13afee68eee23965caf364c3812ca6065eac5655faf9c20d9f231b9b1d","dweb:/ipfs/QmXPdwfDAMniiwJHPt2WBvaT5gK1LUK3aM81Jq5m3n8UPF"],"license":"MIT"}},"version":1},"id":4} \ No newline at end of file diff --git a/tests/contracts/src/DeclaredCallsContract.sol b/tests/contracts/src/DeclaredCallsContract.sol new file mode 100644 index 00000000000..9b53f5f8a9b --- /dev/null +++ b/tests/contracts/src/DeclaredCallsContract.sol @@ -0,0 +1,174 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract DeclaredCallsContract { + // Asset struct for testing struct field access + struct Asset { + address addr; // field 0 + uint256 amount; // field 1 + bool active; // field 2 + } + + // Complex nested struct for advanced testing + struct ComplexAsset { + Asset base; // field 0 + string metadata; // field 1 + uint256[] values; // field 2 + } + + // Events for testing declared calls + event Transfer(address indexed from, address indexed to, uint256 value); + event AssetTransfer(Asset asset, address to, uint256 blockNumber); + event ComplexAssetCreated(ComplexAsset complexAsset, uint256 id); + + // Storage for testing view functions + mapping(address => uint256) public balances; + mapping(address => string) public metadata; + mapping(uint256 => Asset) public assets; + mapping(uint256 => address) public assetOwners; + uint256 public totalSupply; + + // State variables for testing + bool public shouldRevert = false; + uint256 public counter = 0; + + constructor() { + // Initialize some test data + balances[msg.sender] = 1000; + balances[address(0x1111111111111111111111111111111111111111)] = 1000; + balances[address(0x2222222222222222222222222222222222222222)] = 1000; + totalSupply = 3000; + + // Create some test assets + assets[1] = Asset({ + addr: address(0x1111111111111111111111111111111111111111), + amount: 100, + active: true + }); + assetOwners[1] = msg.sender; + metadata[ + address(0x1111111111111111111111111111111111111111) + ] = "Test Asset 1"; + + assets[2] = Asset({ + addr: address(0x2222222222222222222222222222222222222222), + amount: 200, + active: false + }); + assetOwners[2] = msg.sender; + metadata[ + address(0x2222222222222222222222222222222222222222) + ] = "Test Asset 2"; + } + + // Basic functions for declared calls testing + function balanceOf(address account) public view returns (uint256) { + return balances[account]; + } + + function getOwner(address assetAddr) public view returns (address) { + // Find asset by address and return owner + for (uint256 i = 1; i <= 10; i++) { + if (assets[i].addr == assetAddr) { + return assetOwners[i]; + } + } + return address(0); + } + + function getMetadata( + address assetAddr + ) public view returns (string memory) { + return metadata[assetAddr]; + } + + function getAssetAmount(uint256 assetId) public view returns (uint256) { + return assets[assetId].amount; + } + + function isAssetActive(uint256 assetId) public view returns (bool) { + return assets[assetId].active; + } + + // Functions for testing edge cases + function alwaysReverts() public pure returns (bool) { + if (1 > 0) { + revert("This function always reverts"); + } + return true; + } + + function conditionalRevert() public view { + if (shouldRevert) { + revert("Conditional revert triggered"); + } + } + + function incrementCounter() public returns (uint256) { + counter++; + return counter; + } + + // Functions to emit events for testing + function emitTransfer(address from, address to, uint256 value) public { + balances[from] -= value; + balances[to] += value; + emit Transfer(from, to, value); + } + + function emitAssetTransfer( + address assetAddr, + uint256 amount, + bool active, + address to + ) public { + Asset memory asset = Asset({ + addr: assetAddr, + amount: amount, + active: active + }); + emit AssetTransfer(asset, to, block.number); + } + + function emitComplexAssetCreated( + address baseAddr, + uint256 baseAmount, + bool baseActive, + string memory metadataStr, + uint256[] memory values, + uint256 id + ) public { + Asset memory baseAsset = Asset({ + addr: baseAddr, + amount: baseAmount, + active: baseActive + }); + + ComplexAsset memory complexAsset = ComplexAsset({ + base: baseAsset, + metadata: metadataStr, + values: values + }); + + emit ComplexAssetCreated(complexAsset, id); + } + + // Utility functions + function setShouldRevert(bool _shouldRevert) public { + shouldRevert = _shouldRevert; + } + + function getConstant() public pure returns (uint256) { + return 42; + } + + function sum(uint256 a, uint256 b) public pure returns (uint256) { + return a + b; + } + + // Function that doesn't exist in ABI (for testing invalid function calls) + // This will be removed from the ABI manually + function hiddenFunction() public pure returns (uint256) { + return 999; + } +} diff --git a/tests/integration-tests/declared-calls-basic/abis/Contract.abi b/tests/integration-tests/declared-calls-basic/abis/Contract.abi new file mode 120000 index 00000000000..469d21b4a48 --- /dev/null +++ b/tests/integration-tests/declared-calls-basic/abis/Contract.abi @@ -0,0 +1 @@ +../../../contracts/abis/DeclaredCallsContract.json \ No newline at end of file diff --git a/tests/integration-tests/declared-calls-basic/package.json b/tests/integration-tests/declared-calls-basic/package.json new file mode 100644 index 00000000000..a8de0d65d4c --- /dev/null +++ b/tests/integration-tests/declared-calls-basic/package.json @@ -0,0 +1,13 @@ +{ + "name": "declared-calls-basic", + "version": "1.0.0", + "private": true, + "scripts": { + "build": "graph build --ipfs $IPFS_URI", + "codegen": "graph codegen" + }, + "devDependencies": { + "@graphprotocol/graph-cli": "0.97.1", + "@graphprotocol/graph-ts": "0.33.0" + } +} diff --git a/tests/integration-tests/declared-calls-basic/schema.graphql b/tests/integration-tests/declared-calls-basic/schema.graphql new file mode 100644 index 00000000000..3617a551ec8 --- /dev/null +++ b/tests/integration-tests/declared-calls-basic/schema.graphql @@ -0,0 +1,23 @@ +type TransferCall @entity(immutable: true) { + id: ID! + from: Bytes! + to: Bytes! + value: BigInt! + balanceFromBefore: BigInt! + balanceToBefore: BigInt! + totalSupply: BigInt! + constantValue: BigInt! + sumResult: BigInt! + metadataFrom: String! + revertCallSucceeded: Boolean! + blockNumber: BigInt! + transactionHash: Bytes! +} + +type CallResult @entity(immutable: true) { + id: ID! + label: String! + success: Boolean! + value: String + error: String +} diff --git a/tests/integration-tests/declared-calls-basic/src/mapping.ts b/tests/integration-tests/declared-calls-basic/src/mapping.ts new file mode 100644 index 00000000000..fb5f5e52dd7 --- /dev/null +++ b/tests/integration-tests/declared-calls-basic/src/mapping.ts @@ -0,0 +1,94 @@ +import { ethereum, log, BigInt } from "@graphprotocol/graph-ts"; +import { Contract, Transfer } from "../generated/Contract/Contract"; +import { TransferCall, CallResult } from "../generated/schema"; + +export function handleTransfer(event: Transfer): void { + let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString(); + let transferCall = new TransferCall(id); + + transferCall.from = event.params.from; + transferCall.to = event.params.to; + transferCall.value = event.params.value; + transferCall.blockNumber = event.block.number; + transferCall.transactionHash = event.transaction.hash; + + // Test declared calls - these should be available before the handler runs + + // Basic successful calls + const contract = Contract.bind(event.address); + let balanceFromCall = contract.try_balanceOf(event.params.from); + if (!balanceFromCall.reverted) { + transferCall.balanceFromBefore = balanceFromCall.value; + createCallResult(id + "-balance_from", "balance_from", true, balanceFromCall.value.toString(), null); + } else { + transferCall.balanceFromBefore = BigInt.fromI32(0); + createCallResult(id + "-balance_from", "balance_from", false, null, "Call failed"); + } + + let balanceToCall = contract.try_balanceOf(event.params.to); + if (!balanceToCall.reverted) { + transferCall.balanceToBefore = balanceToCall.value; + createCallResult(id + "-balance_to", "balance_to", true, balanceToCall.value.toString(), null); + } else { + transferCall.balanceToBefore = BigInt.fromI32(0); + createCallResult(id + "-balance_to", "balance_to", false, null, "Call failed"); + } + + let totalSupplyCall = contract.try_totalSupply(); + if (!totalSupplyCall.reverted) { + transferCall.totalSupply = totalSupplyCall.value; + createCallResult(id + "-total_supply", "total_supply", true, totalSupplyCall.value.toString(), null); + } else { + transferCall.totalSupply = BigInt.fromI32(0); + createCallResult(id + "-total_supply", "total_supply", false, null, "Call failed"); + } + + let constantCall = contract.try_getConstant(); + if (!constantCall.reverted) { + transferCall.constantValue = constantCall.value; + createCallResult(id + "-constant_value", "constant_value", true, constantCall.value.toString(), null); + } else { + transferCall.constantValue = BigInt.fromI32(0); + createCallResult(id + "-constant_value", "constant_value", false, null, "Call failed"); + } + + let sumCall = contract.try_sum(event.params.value, event.params.value); + if (!sumCall.reverted) { + transferCall.sumResult = sumCall.value; + createCallResult(id + "-sum_values", "sum_values", true, sumCall.value.toString(), null); + } else { + transferCall.sumResult = BigInt.fromI32(0); + createCallResult(id + "-sum_values", "sum_values", false, null, "Call failed"); + } + + let metadataCall = contract.try_getMetadata(event.params.from); + if (!metadataCall.reverted) { + transferCall.metadataFrom = metadataCall.value.toString(); + createCallResult(id + "-metadata_from", "metadata_from", true, metadataCall.value.toString(), null); + } else { + transferCall.metadataFrom = ""; + createCallResult(id + "-metadata_from", "metadata_from", false, null, "Call failed"); + } + + // Test call that should revert + let revertCall = contract.try_alwaysReverts(); + transferCall.revertCallSucceeded = !revertCall.reverted; + if (!revertCall.reverted) { + createCallResult(id + "-will_revert", "will_revert", true, revertCall.value.toString(), null); + log.warning("Expected revert call succeeded unexpectedly", []); + } else { + createCallResult(id + "-will_revert", "will_revert", false, null, "Call reverted as expected"); + log.info("Revert call failed as expected", []); + } + + transferCall.save(); +} + +function createCallResult(id: string, label: string, success: boolean, value: string | null, error: string | null): void { + let callResult = new CallResult(id); + callResult.label = label; + callResult.success = success; + callResult.value = value; + callResult.error = error; + callResult.save(); +} diff --git a/tests/integration-tests/declared-calls-basic/subgraph.yaml b/tests/integration-tests/declared-calls-basic/subgraph.yaml new file mode 100644 index 00000000000..162157385d7 --- /dev/null +++ b/tests/integration-tests/declared-calls-basic/subgraph.yaml @@ -0,0 +1,33 @@ +specVersion: 1.2.0 +schema: + file: ./schema.graphql +dataSources: + - kind: ethereum/contract + name: Contract + network: test + source: + address: "@DeclaredCallsContract@" + abi: Contract + startBlock: 1 + mapping: + kind: ethereum/events + apiVersion: 0.0.7 + language: wasm/assemblyscript + abis: + - name: Contract + file: ./abis/Contract.abi + entities: + - TransferCall + - CallResult + eventHandlers: + - event: Transfer(indexed address,indexed address,uint256) + handler: handleTransfer + calls: + balance_from: "Contract[event.address].balanceOf(event.params.from)" + balance_to: "Contract[event.address].balanceOf(event.params.to)" + total_supply: "Contract[event.address].totalSupply()" + constant_value: "Contract[event.address].getConstant()" + sum_values: "Contract[event.address].sum(event.params.value, event.params.value)" + will_revert: "Contract[event.address].alwaysReverts()" + metadata_from: "Contract[event.address].getMetadata(event.params.from)" + file: ./src/mapping.ts diff --git a/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi b/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi new file mode 120000 index 00000000000..469d21b4a48 --- /dev/null +++ b/tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi @@ -0,0 +1 @@ +../../../contracts/abis/DeclaredCallsContract.json \ No newline at end of file diff --git a/tests/integration-tests/declared-calls-struct-fields/package.json b/tests/integration-tests/declared-calls-struct-fields/package.json new file mode 100644 index 00000000000..8f1d708761b --- /dev/null +++ b/tests/integration-tests/declared-calls-struct-fields/package.json @@ -0,0 +1,13 @@ +{ + "name": "declared-calls-struct-fields", + "version": "1.0.0", + "private": true, + "scripts": { + "build": "graph build --ipfs false", + "codegen": "graph codegen" + }, + "devDependencies": { + "@graphprotocol/graph-cli": "0.97.1", + "@graphprotocol/graph-ts": "0.33.0" + } +} diff --git a/tests/integration-tests/declared-calls-struct-fields/schema.graphql b/tests/integration-tests/declared-calls-struct-fields/schema.graphql new file mode 100644 index 00000000000..564e12eeb9d --- /dev/null +++ b/tests/integration-tests/declared-calls-struct-fields/schema.graphql @@ -0,0 +1,45 @@ +type AssetTransferCall @entity(immutable: true) { + id: ID! + assetAddr: Bytes! + assetAmount: BigInt! + assetActive: Boolean! + to: Bytes! + blockNumber: BigInt! + + # Results from named field access + owner: Bytes! + metadata: String! + amountCalc: BigInt! + + # Regular call result + recipientBalance: BigInt! + + transactionHash: Bytes! +} + +type ComplexAssetCall @entity(immutable: true) { + id: ID! + complexAssetId: BigInt! + baseAssetAddr: Bytes! + baseAssetAmount: BigInt! + baseAssetActive: Boolean! + metadata: String! + + # Results from nested struct field access + baseAssetOwner: Bytes! + baseAssetMetadata: String! + baseAssetAmountCalc: BigInt! + + blockNumber: BigInt! + transactionHash: Bytes! +} + +type StructFieldTest @entity(immutable: true) { + id: ID! + testType: String! + fieldName: String! + success: Boolean! + result: String + error: String + blockNumber: BigInt! +} diff --git a/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts b/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts new file mode 100644 index 00000000000..2f0232b4d38 --- /dev/null +++ b/tests/integration-tests/declared-calls-struct-fields/src/mapping.ts @@ -0,0 +1,120 @@ +import { ethereum, log, BigInt, Address } from "@graphprotocol/graph-ts"; +import { AssetTransfer, ComplexAssetCreated, Contract } from "../generated/Contract/Contract"; +import { AssetTransferCall, ComplexAssetCall, StructFieldTest } from "../generated/schema"; + +export function handleAssetTransfer(event: AssetTransfer): void { + let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString(); + let assetTransferCall = new AssetTransferCall(id); + + // Store event data + assetTransferCall.assetAddr = event.params.asset.addr; + assetTransferCall.assetAmount = event.params.asset.amount; + assetTransferCall.assetActive = event.params.asset.active; + assetTransferCall.to = event.params.to; + assetTransferCall.blockNumber = event.block.number; + assetTransferCall.transactionHash = event.transaction.hash; + + // Test struct field access by index; the mapping code uses named fields, + // but the underlying calls in the manifest are declared using an index + const contract = Contract.bind(event.address); + let ownerCall = contract.try_getOwner(event.params.asset.addr); + if (!ownerCall.reverted) { + assetTransferCall.owner = ownerCall.value; + createStructFieldTest(id + "-owner", "asset_owner", "addr", true, ownerCall.value.toString(), null, event.block.number); + } else { + assetTransferCall.owner = Address.zero(); + createStructFieldTest(id + "-owner", "asset_owner", "addr", false, null, "Call failed", event.block.number); + } + + let metadataCall = contract.try_getMetadata(event.params.asset.addr); + if (!metadataCall.reverted) { + assetTransferCall.metadata = metadataCall.value.toString(); + createStructFieldTest(id + "-metadata-by-name", "asset_metadata", "addr", true, metadataCall.value.toString(), null, event.block.number); + } else { + assetTransferCall.metadata = ""; + createStructFieldTest(id + "-metadata-by-name", "asset_metadata", "addr", false, null, "Call failed", event.block.number); + } + + let amountCalcCall = contract.try_sum(event.params.asset.amount, event.params.asset.amount); + if (!amountCalcCall.reverted) { + assetTransferCall.amountCalc = amountCalcCall.value; + createStructFieldTest(id + "-amount-by-name", "asset_amount", "amount", true, amountCalcCall.value.toString(), null, event.block.number); + } else { + assetTransferCall.amountCalc = BigInt.fromI32(0); + createStructFieldTest(id + "-amount-by-name", "asset_amount", "amount", false, null, "Call failed", event.block.number); + } + + // Regular call (not using struct fields) + let balanceCall = contract.try_balanceOf(event.params.to) + if (!balanceCall.reverted) { + assetTransferCall.recipientBalance = balanceCall.value; + } else { + assetTransferCall.recipientBalance = BigInt.fromI32(0); + } + + assetTransferCall.save(); +} + +export function handleComplexAssetCreated(event: ComplexAssetCreated): void { + let id = event.transaction.hash.toHex() + "-" + event.logIndex.toString(); + let complexAssetCall = new ComplexAssetCall(id); + + // Store event data + complexAssetCall.complexAssetId = event.params.id; + complexAssetCall.baseAssetAddr = event.params.complexAsset.base.addr; + complexAssetCall.baseAssetAmount = event.params.complexAsset.base.amount; + complexAssetCall.baseAssetActive = event.params.complexAsset.base.active; + complexAssetCall.metadata = event.params.complexAsset.metadata; + complexAssetCall.blockNumber = event.block.number; + complexAssetCall.transactionHash = event.transaction.hash; + + // Test nested struct field access + const contract = Contract.bind(event.address); + let baseOwnerCall = contract.try_getOwner(event.params.complexAsset.base.addr); + if (!baseOwnerCall.reverted) { + complexAssetCall.baseAssetOwner = baseOwnerCall.value; + createStructFieldTest(id + "-base-owner", "base_asset", "base.addr", true, baseOwnerCall.value.toString(), null, event.block.number); + } else { + complexAssetCall.baseAssetOwner = Address.zero(); + createStructFieldTest(id + "-base-owner", "base_asset", "base.addr", false, null, "Call failed", event.block.number); + } + + let baseMetadataCall = contract.try_getMetadata(event.params.complexAsset.base.addr); + if (!baseMetadataCall.reverted) { + complexAssetCall.baseAssetMetadata = baseMetadataCall.value.toString(); + createStructFieldTest(id + "-base-metadata", "base_metadata", "base.addr", true, baseMetadataCall.value.toString(), null, event.block.number); + } else { + complexAssetCall.baseAssetMetadata = ""; + createStructFieldTest(id + "-base-metadata", "base_metadata", "base.addr", false, null, "Call failed", event.block.number); + } + + let baseAmountCalcCall = contract.try_sum(event.params.complexAsset.base.amount, event.params.id); + if (!baseAmountCalcCall.reverted) { + complexAssetCall.baseAssetAmountCalc = baseAmountCalcCall.value; + createStructFieldTest(id + "-base-amount", "base_amount", "base.amount", true, baseAmountCalcCall.value.toString(), null, event.block.number); + } else { + complexAssetCall.baseAssetAmountCalc = BigInt.fromI32(0); + createStructFieldTest(id + "-base-amount", "base_amount", "base.amount", false, null, "Call failed", event.block.number); + } + + complexAssetCall.save(); +} + +function createStructFieldTest( + id: string, + testType: string, + fieldName: string, + success: boolean, + result: string | null, + error: string | null, + blockNumber: BigInt +): void { + let test = new StructFieldTest(id); + test.testType = testType; + test.fieldName = fieldName; + test.success = success; + test.result = result; + test.error = error; + test.blockNumber = blockNumber; + test.save(); +} diff --git a/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml b/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml new file mode 100644 index 00000000000..5d8d5767a79 --- /dev/null +++ b/tests/integration-tests/declared-calls-struct-fields/subgraph.yaml @@ -0,0 +1,37 @@ +specVersion: 1.4.0 +schema: + file: ./schema.graphql +dataSources: + - kind: ethereum/contract + name: Contract + network: test + source: + address: "@DeclaredCallsContract@" + abi: Contract + startBlock: 1 + mapping: + kind: ethereum/events + apiVersion: 0.0.7 + language: wasm/assemblyscript + abis: + - name: Contract + file: ./abis/Contract.abi + entities: + - AssetTransferCall + - ComplexAssetCall + - StructFieldTest + eventHandlers: + - event: AssetTransfer((address,uint256,bool),address,uint256) + handler: handleAssetTransfer + calls: + asset_owner: "Contract[event.address].getOwner(event.params.asset.0)" # addr + asset_metadata: "Contract[event.address].getMetadata(event.params.asset.0)" # addr + balance_of_recipient: "Contract[event.address].balanceOf(event.params.to)" + asset_amount: "Contract[event.address].sum(event.params.asset.1, event.params.asset.1)" # amount + - event: ComplexAssetCreated(((address,uint256,bool),string,uint256[]),uint256) + handler: handleComplexAssetCreated + calls: + base_asset_owner: "Contract[event.address].getOwner(event.params.complexAsset.base.addr)" + base_asset_metadata: "Contract[event.address].getMetadata(event.params.complexAsset.base.addr)" + base_asset_amount: "Contract[event.address].sum(event.params.complexAsset.base.amount, event.params.id)" + file: ./src/mapping.ts diff --git a/tests/src/contract.rs b/tests/src/contract.rs index 05fda947839..2d3d72216f3 100644 --- a/tests/src/contract.rs +++ b/tests/src/contract.rs @@ -43,6 +43,10 @@ lazy_static! { name: "OverloadedContract".to_string(), address: Address::from_str("0x0dcd1bf9a1b36ce34237eeafef220932846bcd82").unwrap(), }, + Contract { + name: "DeclaredCallsContract".to_string(), + address: Address::from_str("0x9a676e781a523b5d0c0e43731313a708cb607508").unwrap(), + }, ] }; } @@ -153,6 +157,50 @@ impl Contract { contract.call("emitTrigger", (i as u16,)).await.unwrap(); } } + // Declared calls tests need a Transfer + if contract.name == "DeclaredCallsContract" { + status!("contracts", "Emitting transfers from DeclaredCallsContract"); + let addr1 = "0x1111111111111111111111111111111111111111" + .parse::() + .unwrap(); + let addr2 = "0x2222222222222222222222222222222222222222" + .parse::() + .unwrap(); + let addr3 = "0x3333333333333333333333333333333333333333" + .parse::() + .unwrap(); + let addr4 = "0x4444444444444444444444444444444444444444" + .parse::() + .unwrap(); + + contract + .call("emitTransfer", (addr1, addr2, 100u64)) + .await + .unwrap(); + + // Emit an asset transfer event to trigger struct field declared calls + contract + .call("emitAssetTransfer", (addr1, 150u64, true, addr3)) + .await + .unwrap(); + + // Also emit a complex asset event for nested struct testing + let values = vec![1u64, 2u64, 3u64]; + contract + .call( + "emitComplexAssetCreated", + ( + addr4, + 250u64, + true, + "Complex Asset Metadata".to_string(), + values, + 99u64, + ), + ) + .await + .unwrap(); + } } else { status!( "contracts", diff --git a/tests/src/subgraph.rs b/tests/src/subgraph.rs index 4bd4a17f9ad..dfac2020efe 100644 --- a/tests/src/subgraph.rs +++ b/tests/src/subgraph.rs @@ -4,7 +4,7 @@ use std::{ time::{Duration, Instant}, }; -use anyhow::anyhow; +use anyhow::{anyhow, bail}; use graph::prelude::serde_json::{self, Value}; use serde::Deserialize; @@ -178,4 +178,39 @@ impl Subgraph { let endpoint = CONFIG.graph_node.index_node_uri(); graphql_query_with_vars(&endpoint, text, vars).await } + + /// Poll the subgraph's data API until the `query` returns non-empty + /// results for any of the specified `keys`. The `keys` must be the + /// toplevel entries in the GraphQL `query`. The return value is a + /// vector of vectors, where each inner vector contains the results for + /// one of the specified `keys`, in the order in which they appear in + /// `keys`. + pub async fn polling_query( + &self, + query: &str, + keys: &[&str], + ) -> anyhow::Result>> { + let start = Instant::now(); + loop { + let resp = self.query(query).await?; + + if let Some(errors) = resp.get("errors") { + bail!("GraphQL errors: {:?}", errors); + } + let data = resp["data"].as_object().unwrap(); + let values = keys + .into_iter() + .map(|key| data[*key].as_array().unwrap().clone()) + .collect::>(); + + if !values.iter().all(|item| item.is_empty()) { + break Ok(values); + } + + if start.elapsed() > Duration::from_secs(30) { + bail!("Timed out waiting for declared calls to be indexed"); + } + sleep(Duration::from_millis(100)).await; + } + } } diff --git a/tests/tests/integration_tests.rs b/tests/tests/integration_tests.rs index ebec6fd8fc4..3bfbe95ff8f 100644 --- a/tests/tests/integration_tests.rs +++ b/tests/tests/integration_tests.rs @@ -15,6 +15,7 @@ use std::time::{self, Duration, Instant}; use anyhow::{anyhow, bail, Context, Result}; use graph::futures03::StreamExt; +use graph::itertools::Itertools; use graph::prelude::serde_json::{json, Value}; use graph::prelude::web3::types::U256; use graph_tests::contract::Contract; @@ -1067,6 +1068,225 @@ pub async fn test_multiple_subgraph_datasources(ctx: TestContext) -> anyhow::Res Ok(()) } +/// Test the declared calls functionality as of spec version 1.2.0. +/// Note that we don't have a way to test that the actual call is made as +/// a declared call since graph-node does not expose that information +/// to mappings. This test assures though that the declared call machinery +/// does not have any errors. +async fn test_declared_calls_basic(ctx: TestContext) -> anyhow::Result<()> { + #[track_caller] + fn assert_call_result(call_results: &[Value], label: &str, exp_success: bool, exp_value: &str) { + let Some(call_result) = call_results.iter().find(|c| c["label"] == json!(label)) else { + panic!( + "Expected call result with label '{}', but none found", + label + ); + }; + let Some(act_success) = call_result["success"].as_bool() else { + panic!( + "Expected call result with label '{}' to have a boolean 'success' field, but got: {:?}", + label, call_result["success"] + ); + }; + + if exp_success { + assert!( + act_success, + "Expected call result with label '{}' to be successful", + label + ); + let Some(act_value) = call_result["value"].as_str() else { + panic!( + "Expected call result with label '{}' to have a string 'value' field, but got: {:?}", + label, call_result["value"] + ); + }; + assert_eq!( + exp_value, act_value, + "Expected call result with label '{}' to have value '{}', but got '{}'", + label, exp_value, act_value + ); + } else { + assert!( + !act_success, + "Expected call result with label '{}' to have failed", + label + ); + } + } + + let subgraph = ctx.subgraph; + assert!(subgraph.healthy); + + // Query the results + const QUERY: &'static str = "{ + transferCalls(first: 1, orderBy: blockNumber) { + id + from + to + value + balanceFromBefore + balanceToBefore + totalSupply + constantValue + sumResult + metadataFrom + revertCallSucceeded + } + callResults(orderBy: label) { + label + success + value + error + } + }"; + + let Some((transfer_calls, call_results)) = subgraph + .polling_query(QUERY, &["transferCalls", "callResults"]) + .await? + .into_iter() + .collect_tuple() + else { + panic!("Expected exactly two arrays from polling_query") + }; + + // Validate basic functionality + assert!( + !transfer_calls.is_empty(), + "Should have at least one transfer call" + ); + assert!(!call_results.is_empty(), "Should have call results"); + + let transfer_call = &transfer_calls[0]; + + // Validate declared calls worked + assert_eq!( + transfer_call["constantValue"], + json!("42"), + "Constant value should be 42" + ); + assert_eq!( + transfer_call["sumResult"], + json!("200"), + "Sum result should be 200 (100 + 100)" + ); + assert_eq!( + transfer_call["revertCallSucceeded"], + json!(false), + "Revert call should have failed" + ); + assert_eq!( + transfer_call["totalSupply"], + json!("3000"), + "Total supply should be 3000" + ); + + assert_call_result(&call_results, "balance_from", true, "900"); + assert_call_result(&call_results, "balance_to", true, "1100"); + assert_call_result(&call_results, "constant_value", true, "42"); + assert_call_result(&call_results, "metadata_from", true, "Test Asset 1"); + assert_call_result(&call_results, "sum_values", true, "200"); + assert_call_result(&call_results, "total_supply", true, "3000"); + assert_call_result(&call_results, "will_revert", false, "*ignored*"); + + Ok(()) +} + +async fn test_declared_calls_struct_fields(ctx: TestContext) -> anyhow::Result<()> { + let subgraph = ctx.subgraph; + assert!(subgraph.healthy); + + // Wait a moment for indexing + sleep(Duration::from_secs(2)).await; + + // Query the results + const QUERY: &'static str = "{ + assetTransferCalls(first: 1, orderBy: blockNumber) { + id + assetAddr + assetAmount + assetActive + owner + metadata + amountCalc + } + complexAssetCalls(first: 1, orderBy: blockNumber) { + id + baseAssetAddr + baseAssetAmount + baseAssetOwner + baseAssetMetadata + baseAssetAmountCalc + } + structFieldTests(orderBy: testType) { + testType + fieldName + success + result + error + } + }"; + + let Some((asset_transfers, complex_assets, struct_tests)) = subgraph + .polling_query( + QUERY, + &[ + "assetTransferCalls", + "complexAssetCalls", + "structFieldTests", + ], + ) + .await? + .into_iter() + .collect_tuple() + else { + panic!("Expected exactly three arrays from polling_query") + }; + + // Validate struct field access + assert!( + !asset_transfers.is_empty(), + "Should have asset transfer calls" + ); + assert!( + !complex_assets.is_empty(), + "Should have complex asset calls" + ); + assert!(!struct_tests.is_empty(), "Should have struct field tests"); + + let asset_transfer = &asset_transfers[0]; + + // Validate struct field values + assert_eq!( + asset_transfer["assetAddr"], + json!("0x1111111111111111111111111111111111111111") + ); + assert_eq!(asset_transfer["assetAmount"], json!("150")); + assert_eq!(asset_transfer["assetActive"], json!(true)); + assert_eq!(asset_transfer["amountCalc"], json!("300")); // 150 + 150 + + // Validate complex asset (nested struct access) + let complex_asset = &complex_assets[0]; + assert_eq!( + complex_asset["baseAssetAddr"], + json!("0x4444444444444444444444444444444444444444") + ); + assert_eq!(complex_asset["baseAssetAmount"], json!("250")); + assert_eq!(complex_asset["baseAssetAmountCalc"], json!("349")); // 250 + 99 + + // Validate that struct field tests include both successful calls + let successful_tests: Vec<_> = struct_tests + .iter() + .filter(|t| t["success"] == json!(true)) + .collect(); + assert!( + !successful_tests.is_empty(), + "Should have successful struct field tests" + ); + + Ok(()) +} + async fn wait_for_blockchain_block(block_number: i32) -> bool { // Wait up to 5 minutes for the expected block to appear const STATUS_WAIT: Duration = Duration::from_secs(300); @@ -1115,6 +1335,11 @@ async fn integration_tests() -> anyhow::Result<()> { test_multiple_subgraph_datasources, vec!["source-subgraph-a", "source-subgraph-b"], ), + TestCase::new("declared-calls-basic", test_declared_calls_basic), + TestCase::new( + "declared-calls-struct-fields", + test_declared_calls_struct_fields, + ), ]; // Filter the test cases if a specific test name is provided