From ac82dda22ce7db23898f3e9d252e9abac8999347 Mon Sep 17 00:00:00 2001 From: Sebastian Lorenz Date: Mon, 18 Aug 2025 17:28:55 +0200 Subject: [PATCH] core: Implement struct field access in declarative calls (spec v1.4.0) This commit implements support for struct field access in declarative calls, allowing subgraphs to access nested struct fields using dot notation. Key changes: - Add struct field access parsing and validation - Support arbitrary nesting depth for field access - Update subgraph manifest documentation - Add comprehensive tests for struct field access functionality - Update API version to support new feature - Initial deserialization stores calls as raw strings in UnresolvedCallDecls - Resolution phase parses calls with ABI context using CallExpr::parse() - Spec version validation happens during parsing with clear error messages - Add UnresolvedCallDecls struct to store raw call strings - Add UnresolvedMappingEventHandler and UnresolvedEntityHandler - Move call parsing from deserialization to resolution phase - Replace eprintln! with proper logger.warn() calls - Remove obsolete validation functions - Add a justfile target to recompile test contracts - Extract their ABIs into tests/contracts/abi/ - Add integration tests for using struct fields in declared calls Co-Authored-By: Claude Co-Authored-By: Sebastian Lorenz --- chain/ethereum/src/data_source.rs | 85 +- chain/near/src/data_source.rs | 2 + chain/substreams/src/data_source.rs | 14 +- docs/subgraph-manifest.md | 14 +- graph/src/blockchain/mock.rs | 2 + graph/src/blockchain/mod.rs | 2 + graph/src/data/subgraph/api_version.rs | 5 +- graph/src/data/subgraph/mod.rs | 10 +- graph/src/data_source/common.rs | 1594 +++++++++++++++-- graph/src/data_source/mod.rs | 10 +- graph/src/data_source/subgraph.rs | 84 +- graph/src/env/mod.rs | 2 +- justfile | 21 + pnpm-lock.yaml | 328 +++- tests/.gitignore | 1 + .../contracts/abis/DeclaredCallsContract.json | 532 ++++++ tests/contracts/abis/LimitedContract.json | 32 + tests/contracts/abis/OverloadedContract.json | 70 + tests/contracts/abis/RevertingContract.json | 32 + tests/contracts/abis/SimpleContract.json | 92 + .../DeclaredCallsContract.json | 1 + .../LimitedContract.sol/LimitedContract.json | 2 +- .../OverloadedContract.json | 2 +- .../RevertingContract.json | 2 +- .../SimpleContract.sol/SimpleContract.json | 2 +- tests/contracts/src/DeclaredCallsContract.sol | 174 ++ .../declared-calls-basic/abis/Contract.abi | 1 + .../declared-calls-basic/package.json | 13 + .../declared-calls-basic/schema.graphql | 23 + .../declared-calls-basic/src/mapping.ts | 94 + .../declared-calls-basic/subgraph.yaml | 33 + .../abis/Contract.abi | 1 + .../declared-calls-struct-fields/package.json | 13 + .../schema.graphql | 45 + .../src/mapping.ts | 120 ++ .../subgraph.yaml | 37 + tests/src/contract.rs | 48 + tests/src/subgraph.rs | 37 +- tests/tests/integration_tests.rs | 225 +++ 39 files changed, 3638 insertions(+), 167 deletions(-) create mode 100644 tests/contracts/abis/DeclaredCallsContract.json create mode 100644 tests/contracts/abis/LimitedContract.json create mode 100644 tests/contracts/abis/OverloadedContract.json create mode 100644 tests/contracts/abis/RevertingContract.json create mode 100644 tests/contracts/abis/SimpleContract.json create mode 100644 tests/contracts/out/DeclaredCallsContract.sol/DeclaredCallsContract.json create mode 100644 tests/contracts/src/DeclaredCallsContract.sol create mode 120000 tests/integration-tests/declared-calls-basic/abis/Contract.abi create mode 100644 tests/integration-tests/declared-calls-basic/package.json create mode 100644 tests/integration-tests/declared-calls-basic/schema.graphql create mode 100644 tests/integration-tests/declared-calls-basic/src/mapping.ts create mode 100644 tests/integration-tests/declared-calls-basic/subgraph.yaml create mode 120000 tests/integration-tests/declared-calls-struct-fields/abis/Contract.abi create mode 100644 tests/integration-tests/declared-calls-struct-fields/package.json create mode 100644 tests/integration-tests/declared-calls-struct-fields/schema.graphql create mode 100644 tests/integration-tests/declared-calls-struct-fields/src/mapping.ts create mode 100644 tests/integration-tests/declared-calls-struct-fields/subgraph.yaml 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":"0x60806040525f60055f6101000a81548160ff0219169083151502179055505f6006553480156200002d575f80fd5b506103e85f803373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055506103e85f8073111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20819055506103e85f8073222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f2081905550610bb8600481905550604051806060016040528073111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff168152602001606481526020016001151581525060025f600181526020019081526020015f205f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602082015181600101556040820151816002015f6101000a81548160ff0219169083151502179055509050503360035f600181526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040518060400160405280600c81526020017f546573742041737365742031000000000000000000000000000000000000000081525060015f73111111111111111111111111111111111111111173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209081620002d89190620006f3565b50604051806060016040528073222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff16815260200160c881526020015f151581525060025f600281526020019081526020015f205f820151815f015f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602082015181600101556040820151816002015f6101000a81548160ff0219169083151502179055509050503360035f600281526020019081526020015f205f6101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040518060400160405280600c81526020017f546573742041737365742032000000000000000000000000000000000000000081525060015f73222222222222222222222222222222222222222273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f209081620004889190620006f3565b50620007d7565b5f81519050919050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f60028204905060018216806200050b57607f821691505b602082108103620005215762000520620004c6565b5b50919050565b5f819050815f5260205f209050919050565b5f6020601f8301049050919050565b5f82821b905092915050565b5f60088302620005857fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8262000548565b62000591868362000548565b95508019841693508086168417925050509392505050565b5f819050919050565b5f819050919050565b5f620005db620005d5620005cf84620005a9565b620005b2565b620005a9565b9050919050565b5f819050919050565b620005f683620005bb565b6200060e6200060582620005e2565b84845462000554565b825550505050565b5f90565b6200062462000616565b62000631818484620005eb565b505050565b5b8181101562000658576200064c5f826200061a565b60018101905062000637565b5050565b601f821115620006a757620006718162000527565b6200067c8462000539565b810160208510156200068c578190505b620006a46200069b8562000539565b83018262000636565b50505b505050565b5f82821c905092915050565b5f620006c95f1984600802620006ac565b1980831691505092915050565b5f620006e38383620006b8565b9150826002028217905092915050565b620006fe826200048f565b67ffffffffffffffff8111156200071a576200071962000499565b5b620007268254620004f3565b620007338282856200065c565b5f60209050601f83116001811462000769575f841562000754578287015190505b620007608582620006d6565b865550620007cf565b601f198416620007798662000527565b5f5b82811015620007a2578489015182556001820191506020850194506020810190506200077b565b86831015620007c25784890151620007be601f891682620006b8565b8355505b6001600288020188555050505b505050505050565b6115dd80620007e55f395ff3fe608060405234801561000f575f80fd5b5060043610610140575f3560e01c806370a08231116100b6578063cad0899b1161007a578063cad0899b14610388578063cd63468a146103b8578063cf35bdd0146103d4578063d3072d8214610406578063f13a38a614610424578063fa5441611461044257610140565b806370a08231146102e257806392eaff8314610312578063a718c0d914610342578063b4f5537d14610360578063bcd0aaf81461037e57610140565b80632ba21572116101085780632ba215721461020e5780634d6f99821461023e5780635b34b9661461025a57806361bc221a146102785780636813d787146102965780636999f843146102b257610140565b806318160ddd1461014457806322e900c21461016257806323de66511461019257806327e235e3146101ae5780632a50c146146101de575b5f80fd5b61014c610472565b6040516101599190610b16565b60405180910390f35b61017c60048036038101906101779190610b6a565b610478565b6040516101899190610baf565b60405180910390f35b6101ac60048036038101906101a79190610c22565b6104a1565b005b6101c860048036038101906101c39190610c72565b6105af565b6040516101d59190610b16565b60405180910390f35b6101f860048036038101906101f39190610c72565b6105c3565b6040516102059190610d27565b60405180910390f35b61022860048036038101906102239190610c72565b610690565b6040516102359190610d27565b60405180910390f35b61025860048036038101906102539190610d71565b61072b565b005b6102626107a3565b60405161026f9190610b16565b60405180910390f35b6102806107c3565b60405161028d9190610b16565b60405180910390f35b6102b060048036038101906102ab9190610dd5565b6107c9565b005b6102cc60048036038101906102c79190610b6a565b6107e5565b6040516102d99190610e0f565b60405180910390f35b6102fc60048036038101906102f79190610c72565b610815565b6040516103099190610b16565b60405180910390f35b61032c60048036038101906103279190610b6a565b61085a565b6040516103399190610b16565b60405180910390f35b61034a610877565b6040516103579190610b16565b60405180910390f35b610368610880565b6040516103759190610baf565b60405180910390f35b6103866108cc565b005b6103a2600480360381019061039d9190610e28565b61091d565b6040516103af9190610b16565b60405180910390f35b6103d260048036038101906103cd9190611056565b610932565b005b6103ee60048036038101906103e99190610b6a565b6109c9565b6040516103fd93929190611117565b60405180910390f35b61040e610a1a565b60405161041b9190610baf565b60405180910390f35b61042c610a2c565b6040516104399190610b16565b60405180910390f35b61045c60048036038101906104579190610c72565b610a34565b6040516104699190610e0f565b60405180910390f35b60045481565b5f60025f8381526020019081526020015f206002015f9054906101000a900460ff169050919050565b805f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546104ec9190611179565b92505081905550805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461053e91906111ac565b925050819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516105a29190610b16565b60405180910390a3505050565b5f602052805f5260405f205f915090505481565b606060015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20805461060d9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106399061120c565b80156106845780601f1061065b57610100808354040283529160200191610684565b820191905f5260205f20905b81548152906001019060200180831161066757829003601f168201915b50505050509050919050565b6001602052805f5260405f205f9150905080546106ac9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106d89061120c565b80156107235780601f106106fa57610100808354040283529160200191610723565b820191905f5260205f20905b81548152906001019060200180831161070657829003601f168201915b505050505081565b5f60405180606001604052808673ffffffffffffffffffffffffffffffffffffffff16815260200185815260200184151581525090507fb316a05559699c6f7bf707596924f7a3dbcdda140602bdecdcf504da557b5a00818343604051610794939291906112a9565b60405180910390a15050505050565b5f60065f8154809291906107b6906112de565b9190505550600654905090565b60065481565b8060055f6101000a81548160ff02191690831515021790555050565b6003602052805f5260405f205f915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b5f60025f8381526020019081526020015f20600101549050919050565b5f6103e7905090565b5f80600111156108c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108bc9061136f565b60405180910390fd5b6001905090565b60055f9054906101000a900460ff161561091b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610912906113d7565b60405180910390fd5b565b5f818361092a91906111ac565b905092915050565b5f60405180606001604052808873ffffffffffffffffffffffffffffffffffffffff16815260200187815260200186151581525090505f60405180606001604052808381526020018681526020018581525090507f22bbb405fdf09441de4475115f78ff52520e05a54678d2e90981609fcff4c77781846040516109b7929190611579565b60405180910390a15050505050505050565b6002602052805f5260405f205f91509050805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690806001015490806002015f9054906101000a900460ff16905083565b60055f9054906101000a900460ff1681565b5f602a905090565b5f80600190505b600a8111610af4578273ffffffffffffffffffffffffffffffffffffffff1660025f8381526020019081526020015f205f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1603610ae15760035f8281526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16915050610af9565b8080610aec906112de565b915050610a3b565b505f90505b919050565b5f819050919050565b610b1081610afe565b82525050565b5f602082019050610b295f830184610b07565b92915050565b5f604051905090565b5f80fd5b5f80fd5b610b4981610afe565b8114610b53575f80fd5b50565b5f81359050610b6481610b40565b92915050565b5f60208284031215610b7f57610b7e610b38565b5b5f610b8c84828501610b56565b91505092915050565b5f8115159050919050565b610ba981610b95565b82525050565b5f602082019050610bc25f830184610ba0565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f610bf182610bc8565b9050919050565b610c0181610be7565b8114610c0b575f80fd5b50565b5f81359050610c1c81610bf8565b92915050565b5f805f60608486031215610c3957610c38610b38565b5b5f610c4686828701610c0e565b9350506020610c5786828701610c0e565b9250506040610c6886828701610b56565b9150509250925092565b5f60208284031215610c8757610c86610b38565b5b5f610c9484828501610c0e565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b83811015610cd4578082015181840152602081019050610cb9565b5f8484015250505050565b5f601f19601f8301169050919050565b5f610cf982610c9d565b610d038185610ca7565b9350610d13818560208601610cb7565b610d1c81610cdf565b840191505092915050565b5f6020820190508181035f830152610d3f8184610cef565b905092915050565b610d5081610b95565b8114610d5a575f80fd5b50565b5f81359050610d6b81610d47565b92915050565b5f805f8060808587031215610d8957610d88610b38565b5b5f610d9687828801610c0e565b9450506020610da787828801610b56565b9350506040610db887828801610d5d565b9250506060610dc987828801610c0e565b91505092959194509250565b5f60208284031215610dea57610de9610b38565b5b5f610df784828501610d5d565b91505092915050565b610e0981610be7565b82525050565b5f602082019050610e225f830184610e00565b92915050565b5f8060408385031215610e3e57610e3d610b38565b5b5f610e4b85828601610b56565b9250506020610e5c85828601610b56565b9150509250929050565b5f80fd5b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b610ea482610cdf565b810181811067ffffffffffffffff82111715610ec357610ec2610e6e565b5b80604052505050565b5f610ed5610b2f565b9050610ee18282610e9b565b919050565b5f67ffffffffffffffff821115610f0057610eff610e6e565b5b610f0982610cdf565b9050602081019050919050565b828183375f83830152505050565b5f610f36610f3184610ee6565b610ecc565b905082815260208101848484011115610f5257610f51610e6a565b5b610f5d848285610f16565b509392505050565b5f82601f830112610f7957610f78610e66565b5b8135610f89848260208601610f24565b91505092915050565b5f67ffffffffffffffff821115610fac57610fab610e6e565b5b602082029050602081019050919050565b5f80fd5b5f610fd3610fce84610f92565b610ecc565b90508083825260208201905060208402830185811115610ff657610ff5610fbd565b5b835b8181101561101f578061100b8882610b56565b845260208401935050602081019050610ff8565b5050509392505050565b5f82601f83011261103d5761103c610e66565b5b813561104d848260208601610fc1565b91505092915050565b5f805f805f8060c087890312156110705761106f610b38565b5b5f61107d89828a01610c0e565b965050602061108e89828a01610b56565b955050604061109f89828a01610d5d565b945050606087013567ffffffffffffffff8111156110c0576110bf610b3c565b5b6110cc89828a01610f65565b935050608087013567ffffffffffffffff8111156110ed576110ec610b3c565b5b6110f989828a01611029565b92505060a061110a89828a01610b56565b9150509295509295509295565b5f60608201905061112a5f830186610e00565b6111376020830185610b07565b6111446040830184610ba0565b949350505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61118382610afe565b915061118e83610afe565b92508282039050818111156111a6576111a561114c565b5b92915050565b5f6111b682610afe565b91506111c183610afe565b92508282019050808211156111d9576111d861114c565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061122357607f821691505b602082108103611236576112356111df565b5b50919050565b61124581610be7565b82525050565b61125481610afe565b82525050565b61126381610b95565b82525050565b606082015f82015161127d5f85018261123c565b506020820151611290602085018261124b565b5060408201516112a3604085018261125a565b50505050565b5f60a0820190506112bc5f830186611269565b6112c96060830185610e00565b6112d66080830184610b07565b949350505050565b5f6112e882610afe565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361131a5761131961114c565b5b600182019050919050565b7f546869732066756e6374696f6e20616c776179732072657665727473000000005f82015250565b5f611359601c83610ca7565b915061136482611325565b602082019050919050565b5f6020820190508181035f8301526113868161134d565b9050919050565b7f436f6e646974696f6e616c2072657665727420747269676765726564000000005f82015250565b5f6113c1601c83610ca7565b91506113cc8261138d565b602082019050919050565b5f6020820190508181035f8301526113ee816113b5565b9050919050565b606082015f8201516114095f85018261123c565b50602082015161141c602085018261124b565b50604082015161142f604085018261125a565b50505050565b5f82825260208201905092915050565b5f61144f82610c9d565b6114598185611435565b9350611469818560208601610cb7565b61147281610cdf565b840191505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f6114b1838361124b565b60208301905092915050565b5f602082019050919050565b5f6114d38261147d565b6114dd8185611487565b93506114e883611497565b805f5b838110156115185781516114ff88826114a6565b975061150a836114bd565b9250506001810190506114eb565b5085935050505092915050565b5f60a083015f83015161153a5f8601826113f5565b50602083015184820360608601526115528282611445565b9150506040830151848203608086015261156c82826114c9565b9150508091505092915050565b5f6040820190508181035f8301526115918185611525565b90506115a06020830184610b07565b939250505056fea26469706673582212205465cabdbb10fd7ab5c349f524281ac28f3a7e329ede907a8787a65051b4a20a64736f6c63430008160033","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":"0x608060405234801561000f575f80fd5b5060043610610140575f3560e01c806370a08231116100b6578063cad0899b1161007a578063cad0899b14610388578063cd63468a146103b8578063cf35bdd0146103d4578063d3072d8214610406578063f13a38a614610424578063fa5441611461044257610140565b806370a08231146102e257806392eaff8314610312578063a718c0d914610342578063b4f5537d14610360578063bcd0aaf81461037e57610140565b80632ba21572116101085780632ba215721461020e5780634d6f99821461023e5780635b34b9661461025a57806361bc221a146102785780636813d787146102965780636999f843146102b257610140565b806318160ddd1461014457806322e900c21461016257806323de66511461019257806327e235e3146101ae5780632a50c146146101de575b5f80fd5b61014c610472565b6040516101599190610b16565b60405180910390f35b61017c60048036038101906101779190610b6a565b610478565b6040516101899190610baf565b60405180910390f35b6101ac60048036038101906101a79190610c22565b6104a1565b005b6101c860048036038101906101c39190610c72565b6105af565b6040516101d59190610b16565b60405180910390f35b6101f860048036038101906101f39190610c72565b6105c3565b6040516102059190610d27565b60405180910390f35b61022860048036038101906102239190610c72565b610690565b6040516102359190610d27565b60405180910390f35b61025860048036038101906102539190610d71565b61072b565b005b6102626107a3565b60405161026f9190610b16565b60405180910390f35b6102806107c3565b60405161028d9190610b16565b60405180910390f35b6102b060048036038101906102ab9190610dd5565b6107c9565b005b6102cc60048036038101906102c79190610b6a565b6107e5565b6040516102d99190610e0f565b60405180910390f35b6102fc60048036038101906102f79190610c72565b610815565b6040516103099190610b16565b60405180910390f35b61032c60048036038101906103279190610b6a565b61085a565b6040516103399190610b16565b60405180910390f35b61034a610877565b6040516103579190610b16565b60405180910390f35b610368610880565b6040516103759190610baf565b60405180910390f35b6103866108cc565b005b6103a2600480360381019061039d9190610e28565b61091d565b6040516103af9190610b16565b60405180910390f35b6103d260048036038101906103cd9190611056565b610932565b005b6103ee60048036038101906103e99190610b6a565b6109c9565b6040516103fd93929190611117565b60405180910390f35b61040e610a1a565b60405161041b9190610baf565b60405180910390f35b61042c610a2c565b6040516104399190610b16565b60405180910390f35b61045c60048036038101906104579190610c72565b610a34565b6040516104699190610e0f565b60405180910390f35b60045481565b5f60025f8381526020019081526020015f206002015f9054906101000a900460ff169050919050565b805f808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f8282546104ec9190611179565b92505081905550805f808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f205f82825461053e91906111ac565b925050819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516105a29190610b16565b60405180910390a3505050565b5f602052805f5260405f205f915090505481565b606060015f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20805461060d9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106399061120c565b80156106845780601f1061065b57610100808354040283529160200191610684565b820191905f5260205f20905b81548152906001019060200180831161066757829003601f168201915b50505050509050919050565b6001602052805f5260405f205f9150905080546106ac9061120c565b80601f01602080910402602001604051908101604052809291908181526020018280546106d89061120c565b80156107235780601f106106fa57610100808354040283529160200191610723565b820191905f5260205f20905b81548152906001019060200180831161070657829003601f168201915b505050505081565b5f60405180606001604052808673ffffffffffffffffffffffffffffffffffffffff16815260200185815260200184151581525090507fb316a05559699c6f7bf707596924f7a3dbcdda140602bdecdcf504da557b5a00818343604051610794939291906112a9565b60405180910390a15050505050565b5f60065f8154809291906107b6906112de565b9190505550600654905090565b60065481565b8060055f6101000a81548160ff02191690831515021790555050565b6003602052805f5260405f205f915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b5f805f8373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020015f20549050919050565b5f60025f8381526020019081526020015f20600101549050919050565b5f6103e7905090565b5f80600111156108c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108bc9061136f565b60405180910390fd5b6001905090565b60055f9054906101000a900460ff161561091b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610912906113d7565b60405180910390fd5b565b5f818361092a91906111ac565b905092915050565b5f60405180606001604052808873ffffffffffffffffffffffffffffffffffffffff16815260200187815260200186151581525090505f60405180606001604052808381526020018681526020018581525090507f22bbb405fdf09441de4475115f78ff52520e05a54678d2e90981609fcff4c77781846040516109b7929190611579565b60405180910390a15050505050505050565b6002602052805f5260405f205f91509050805f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690806001015490806002015f9054906101000a900460ff16905083565b60055f9054906101000a900460ff1681565b5f602a905090565b5f80600190505b600a8111610af4578273ffffffffffffffffffffffffffffffffffffffff1660025f8381526020019081526020015f205f015f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1603610ae15760035f8281526020019081526020015f205f9054906101000a900473ffffffffffffffffffffffffffffffffffffffff16915050610af9565b8080610aec906112de565b915050610a3b565b505f90505b919050565b5f819050919050565b610b1081610afe565b82525050565b5f602082019050610b295f830184610b07565b92915050565b5f604051905090565b5f80fd5b5f80fd5b610b4981610afe565b8114610b53575f80fd5b50565b5f81359050610b6481610b40565b92915050565b5f60208284031215610b7f57610b7e610b38565b5b5f610b8c84828501610b56565b91505092915050565b5f8115159050919050565b610ba981610b95565b82525050565b5f602082019050610bc25f830184610ba0565b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f610bf182610bc8565b9050919050565b610c0181610be7565b8114610c0b575f80fd5b50565b5f81359050610c1c81610bf8565b92915050565b5f805f60608486031215610c3957610c38610b38565b5b5f610c4686828701610c0e565b9350506020610c5786828701610c0e565b9250506040610c6886828701610b56565b9150509250925092565b5f60208284031215610c8757610c86610b38565b5b5f610c9484828501610c0e565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b83811015610cd4578082015181840152602081019050610cb9565b5f8484015250505050565b5f601f19601f8301169050919050565b5f610cf982610c9d565b610d038185610ca7565b9350610d13818560208601610cb7565b610d1c81610cdf565b840191505092915050565b5f6020820190508181035f830152610d3f8184610cef565b905092915050565b610d5081610b95565b8114610d5a575f80fd5b50565b5f81359050610d6b81610d47565b92915050565b5f805f8060808587031215610d8957610d88610b38565b5b5f610d9687828801610c0e565b9450506020610da787828801610b56565b9350506040610db887828801610d5d565b9250506060610dc987828801610c0e565b91505092959194509250565b5f60208284031215610dea57610de9610b38565b5b5f610df784828501610d5d565b91505092915050565b610e0981610be7565b82525050565b5f602082019050610e225f830184610e00565b92915050565b5f8060408385031215610e3e57610e3d610b38565b5b5f610e4b85828601610b56565b9250506020610e5c85828601610b56565b9150509250929050565b5f80fd5b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b610ea482610cdf565b810181811067ffffffffffffffff82111715610ec357610ec2610e6e565b5b80604052505050565b5f610ed5610b2f565b9050610ee18282610e9b565b919050565b5f67ffffffffffffffff821115610f0057610eff610e6e565b5b610f0982610cdf565b9050602081019050919050565b828183375f83830152505050565b5f610f36610f3184610ee6565b610ecc565b905082815260208101848484011115610f5257610f51610e6a565b5b610f5d848285610f16565b509392505050565b5f82601f830112610f7957610f78610e66565b5b8135610f89848260208601610f24565b91505092915050565b5f67ffffffffffffffff821115610fac57610fab610e6e565b5b602082029050602081019050919050565b5f80fd5b5f610fd3610fce84610f92565b610ecc565b90508083825260208201905060208402830185811115610ff657610ff5610fbd565b5b835b8181101561101f578061100b8882610b56565b845260208401935050602081019050610ff8565b5050509392505050565b5f82601f83011261103d5761103c610e66565b5b813561104d848260208601610fc1565b91505092915050565b5f805f805f8060c087890312156110705761106f610b38565b5b5f61107d89828a01610c0e565b965050602061108e89828a01610b56565b955050604061109f89828a01610d5d565b945050606087013567ffffffffffffffff8111156110c0576110bf610b3c565b5b6110cc89828a01610f65565b935050608087013567ffffffffffffffff8111156110ed576110ec610b3c565b5b6110f989828a01611029565b92505060a061110a89828a01610b56565b9150509295509295509295565b5f60608201905061112a5f830186610e00565b6111376020830185610b07565b6111446040830184610ba0565b949350505050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b5f61118382610afe565b915061118e83610afe565b92508282039050818111156111a6576111a561114c565b5b92915050565b5f6111b682610afe565b91506111c183610afe565b92508282019050808211156111d9576111d861114c565b5b92915050565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52602260045260245ffd5b5f600282049050600182168061122357607f821691505b602082108103611236576112356111df565b5b50919050565b61124581610be7565b82525050565b61125481610afe565b82525050565b61126381610b95565b82525050565b606082015f82015161127d5f85018261123c565b506020820151611290602085018261124b565b5060408201516112a3604085018261125a565b50505050565b5f60a0820190506112bc5f830186611269565b6112c96060830185610e00565b6112d66080830184610b07565b949350505050565b5f6112e882610afe565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361131a5761131961114c565b5b600182019050919050565b7f546869732066756e6374696f6e20616c776179732072657665727473000000005f82015250565b5f611359601c83610ca7565b915061136482611325565b602082019050919050565b5f6020820190508181035f8301526113868161134d565b9050919050565b7f436f6e646974696f6e616c2072657665727420747269676765726564000000005f82015250565b5f6113c1601c83610ca7565b91506113cc8261138d565b602082019050919050565b5f6020820190508181035f8301526113ee816113b5565b9050919050565b606082015f8201516114095f85018261123c565b50602082015161141c602085018261124b565b50604082015161142f604085018261125a565b50505050565b5f82825260208201905092915050565b5f61144f82610c9d565b6114598185611435565b9350611469818560208601610cb7565b61147281610cdf565b840191505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f819050602082019050919050565b5f6114b1838361124b565b60208301905092915050565b5f602082019050919050565b5f6114d38261147d565b6114dd8185611487565b93506114e883611497565b805f5b838110156115185781516114ff88826114a6565b975061150a836114bd565b9250506001810190506114eb565b5085935050505092915050565b5f60a083015f83015161153a5f8601826113f5565b50602083015184820360608601526115528282611445565b9150506040830151848203608086015261156c82826114c9565b9150508091505092915050565b5f6040820190508181035f8301526115918185611525565b90506115a06020830184610b07565b939250505056fea26469706673582212205465cabdbb10fd7ab5c349f524281ac28f3a7e329ede907a8787a65051b4a20a64736f6c63430008160033","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":"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","sourceMap":"57:457:2:-:0;;;113:45;;;;;;;;;;142:9;;;;;;;;;;57:457;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x608060405234801561000f575f80fd5b506004361061003f575f3560e01c806331870cbc14610043578063934bc29d14610073578063bc2d73ba146100a3575b5f80fd5b61005d600480360381019061005891906101a0565b6100d3565b60405161006a91906101e3565b60405180910390f35b61008d60048036038101906100889190610226565b6100de565b60405161009a91906102db565b60405180910390f35b6100bd60048036038101906100b89190610427565b61011d565b6040516100ca91906102db565b60405180910390f35b5f6101009050919050565b60606040518060400160405280601181526020017f75696e74323536202d3e20737472696e670000000000000000000000000000008152509050919050565b60606040518060400160405280601081526020017f737472696e67202d3e20737472696e67000000000000000000000000000000008152509050919050565b5f604051905090565b5f80fd5b5f80fd5b5f819050919050565b61017f8161016d565b8114610189575f80fd5b50565b5f8135905061019a81610176565b92915050565b5f602082840312156101b5576101b4610165565b5b5f6101c28482850161018c565b91505092915050565b5f819050919050565b6101dd816101cb565b82525050565b5f6020820190506101f65f8301846101d4565b92915050565b610205816101cb565b811461020f575f80fd5b50565b5f81359050610220816101fc565b92915050565b5f6020828403121561023b5761023a610165565b5b5f61024884828501610212565b91505092915050565b5f81519050919050565b5f82825260208201905092915050565b5f5b8381101561028857808201518184015260208101905061026d565b5f8484015250505050565b5f601f19601f8301169050919050565b5f6102ad82610251565b6102b7818561025b565b93506102c781856020860161026b565b6102d081610293565b840191505092915050565b5f6020820190508181035f8301526102f381846102a3565b905092915050565b5f80fd5b5f80fd5b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b61033982610293565b810181811067ffffffffffffffff8211171561035857610357610303565b5b80604052505050565b5f61036a61015c565b90506103768282610330565b919050565b5f67ffffffffffffffff82111561039557610394610303565b5b61039e82610293565b9050602081019050919050565b828183375f83830152505050565b5f6103cb6103c68461037b565b610361565b9050828152602081018484840111156103e7576103e66102ff565b5b6103f28482856103ab565b509392505050565b5f82601f83011261040e5761040d6102fb565b5b813561041e8482602086016103b9565b91505092915050565b5f6020828403121561043c5761043b610165565b5b5f82013567ffffffffffffffff81111561045957610458610169565b5b610465848285016103fa565b9150509291505056fea2646970667358221220f510af729492328df1260e592035db6462a7a7d948201d9ae530b6258c5cf40364736f6c63430008160033","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":"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","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