diff --git a/.github/workflows/basic-rust.yml b/.github/workflows/basic-rust.yml index ca20ec985..e13a848b8 100644 --- a/.github/workflows/basic-rust.yml +++ b/.github/workflows/basic-rust.yml @@ -21,7 +21,7 @@ jobs: steps: - name: Checkout sources - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Cache Rust dependencies uses: Swatinem/rust-cache@v2 @@ -42,7 +42,7 @@ jobs: working-directory: contracts/cosmwasm-vm steps: - name: Checkout sources - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Cache Rust dependencies uses: Swatinem/rust-cache@v2 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 6c7422677..d1577a877 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -57,7 +57,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout source code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: submodules: true - name: Install Foundry diff --git a/Cargo.lock b/Cargo.lock index 224d4770e..508c18dc8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -199,10 +199,24 @@ dependencies = [ [[package]] name = "cluster-connection" -version = "0.0.0" +version = "0.1.0" dependencies = [ - "soroban-rlp", - "soroban-sdk", + "common", + "cosmwasm", + "cosmwasm-schema", + "cosmwasm-std", + "cw-storage-plus 1.1.0", + "cw-xcall-lib 0.1.0", + "cw2 1.0.1", + "getrandom", + "hex", + "k256 0.13.4", + "schemars 0.8.12", + "serde", + "serde-json-wasm 0.5.2", + "sha2 0.10.8", + "sha3", + "thiserror", ] [[package]] @@ -260,14 +274,13 @@ dependencies = [ [[package]] name = "cosmwasm-crypto" -version = "1.5.5" +version = "1.5.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd50718a2b6830ce9eb5d465de5a018a12e71729d66b70807ce97e6dd14f931d" +checksum = "58535cbcd599b3c193e3967c8292fe1dbbb5de7c2a2d87380661091dd4744044" dependencies = [ "digest 0.10.7", - "ecdsa 0.16.9", "ed25519-zebra", - "k256 0.13.1", + "k256 0.13.4", "rand_core 0.6.4", "thiserror", ] @@ -1409,9 +1422,9 @@ dependencies = [ [[package]] name = "k256" -version = "0.13.1" +version = "0.13.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cadb76004ed8e97623117f3df85b17aaa6626ab0b0831e6573f104df16cd1bcc" +checksum = "f6e3919bbaa2945715f0bb6d3934a173d1e9a59ac23767fbaaef277265a7411b" dependencies = [ "cfg-if", "ecdsa 0.16.9", @@ -1488,9 +1501,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.18.0" +version = "1.20.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" [[package]] name = "opaque-debug" diff --git a/contracts/cosmwasm-vm/README.md b/contracts/cosmwasm-vm/README.md index 253ca57f0..93eaaa538 100644 --- a/contracts/cosmwasm-vm/README.md +++ b/contracts/cosmwasm-vm/README.md @@ -4,24 +4,24 @@ This Repo contains the smart contracts for ICON-IBC in rust. ### Standard Libraries -| Crate | Usage | Download | -|----------------|--------------------|-------------------------| -|cosmwasm-schema |Contract Development| [![cosmwasm-schema on crates.io](https://img.shields.io/crates/v/cosmwasm-schema.svg)](https://crates.io/crates/cosmwasm-schema) | -|cosmwasm-std |Contract Development| [![cosmwasm-std on crates.io](https://img.shields.io/crates/v/cosmwasm-std.svg)](https://crates.io/crates/cosmwasm-std) | -|cosmwasm-storage|Contract Development| [![cosmwasm-storage on crates.io](https://img.shields.io/crates/v/cosmwasm-storage.svg)](https://crates.io/crates/cosmwasm-storage) - -| Specification | Crates.io | Coverage | -|--------------- |-------------------------------|----------------------------| -| cw-ibc-core |[![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc)| [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration)| -|cw-icon-light-client|[![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc)| [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration)| -| cw-xcall |[![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc)| [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration)| +| Crate | Usage | Download | +| ---------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | +| cosmwasm-schema | Contract Development | [![cosmwasm-schema on crates.io](https://img.shields.io/crates/v/cosmwasm-schema.svg)](https://crates.io/crates/cosmwasm-schema) | +| cosmwasm-std | Contract Development | [![cosmwasm-std on crates.io](https://img.shields.io/crates/v/cosmwasm-std.svg)](https://crates.io/crates/cosmwasm-std) | +| cosmwasm-storage | Contract Development | [![cosmwasm-storage on crates.io](https://img.shields.io/crates/v/cosmwasm-storage.svg)](https://crates.io/crates/cosmwasm-storage) | + +| Specification | Crates.io | Coverage | +| -------------------- | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| cw-ibc-core | [![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc) | [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration) | +| cw-icon-light-client | [![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc) | [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration) | +| cw-xcall | [![ibc on crates.io](https://img.shields.io/crates/v/ibc.svg)](https://crates.io/crates/ibc) | [![codecov](https://codecov.io/gh/icon-project/IBC-Integration/branch/main/graph/badge.svg?token=8KX6y8aGom)](https://codecov.io/gh/icon-project/IBC-Integration) | ### Prerequiste - To install Rust in Linux/Mac, First, [install rustup](https://rustup.rs/). Once installed, make sure you have the wasm32 target: - + ```shell rustup default stable cargo version @@ -38,19 +38,19 @@ Download and run, [rustup-init.exe](https://static.rust-lang.org/rustup/dist/i68 ### Build Contracts - Execute the following command to compile the contract - + ``` cargo wasm ``` - Optimise using cargo, by giving the following command - + ``` RUSTFLAGS='-C link-arg=-s' cargo wasm ``` - Deploy the contract on testnet - + ``` // add the wasm binary file path in @@ -58,7 +58,7 @@ Download and run, [rustup-init.exe](https://static.rust-lang.org/rustup/dist/i68 ``` - Getting CodeId from RES - + ``` CODE_ID=$(echo $RES | jq -r '.logs[0].events[-1].attributes[1].value') ``` @@ -110,7 +110,7 @@ The xCall contract in Inter-Blockchain Communication (IBC) protocol facilitate c IBC-Core is the reference implementation of the Inter-Blockchain Communication (IBC) protocol, which is a standardized protocol for enabling communication and interoperability between independent blockchain networks. - [ics02_client](./cw-ibc-core/src/ics02_client/) : - + ICS02-Client is a module in the IBC-Core that provides a standard interface and protocol for verifying the state of a remote chain in the Inter-Blockchain Communication (IBC) protocol. - [ics03_connection](./cw-ibc-core/src/ics03_connection/) : @@ -147,4 +147,4 @@ cargo test ### References - [cosmwasm_book](https://book.cosmwasm.com/) -- [ibc-rs](https://github.com/cosmos/ibc-rs/tree/main/crates/ibc) \ No newline at end of file +- [ibc-rs](https://github.com/cosmos/ibc-rs/tree/main/crates/ibc) diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/Cargo.toml b/contracts/cosmwasm-vm/cw-cluster-connection/Cargo.toml new file mode 100644 index 000000000..471972fc5 --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/Cargo.toml @@ -0,0 +1,48 @@ +[package] +name = "cluster-connection" +version = "0.1.0" +edition = "2021" + +exclude = [ + # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication. + "contract.wasm", + "hash.txt", +] + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[lib] +crate-type = ["cdylib", "rlib"] + +[features] +# for more explicit tests, cargo test --features=backtraces +backtraces = ["cosmwasm-std/backtraces"] +library = [] + +[package.metadata.scripts] +optimize = """docker run --rm -v "$(pwd)":/code \ + --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target \ + --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \ + cosmwasm/rust-optimizer:0.12.10 +""" + +[dependencies] +cosmwasm-schema = {workspace=true} +cosmwasm-std = { workspace=true} +cw-storage-plus = {workspace=true} +cw2 = {workspace=true} +schemars = {workspace=true} +serde = { workspace=true} +thiserror = { workspace=true} +common ={ workspace=true} +cw-xcall-lib = { path="../cw-xcall-lib" } +hex = "0.4.3" +serde-json-wasm = {workspace=true} +sha2 = { version = "0.10.6", default-features = false } +sha3 = { version = "0.10.6", default-features = false } +k256 = "0.13.3" + +[dev-dependencies] +cosmwasm = "0.7.2" +getrandom = {version = "0.2", default-features = false, features = ["custom"]} + diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/contract.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/contract.rs new file mode 100644 index 000000000..eeae2ad6b --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/contract.rs @@ -0,0 +1,240 @@ +use cosmwasm_std::{coins, Addr, BankMsg, Event, Uint128}; +use cw_xcall_lib::network_address::NetId; + +use super::*; + +// version info for migration info +const CONTRACT_NAME: &str = "crates.io:cluster-connection"; +const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION"); + +const DEFAULT_SIGNATURE_THRESHOLD: u8 = 1; + +impl<'a> ClusterConnection<'a> { + pub fn instantiate( + &mut self, + deps: DepsMut, + _env: Env, + _info: MessageInfo, + msg: InstantiateMsg, + ) -> Result { + set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?; + + let xcall_address = deps.api.addr_validate(&msg.xcall_address)?; + self.store_xcall(deps.storage, xcall_address)?; + + self.store_admin(deps.storage, _info.sender)?; + + let relayer = deps.api.addr_validate(&msg.relayer)?; + self.store_relayer(deps.storage, relayer)?; + + self.store_denom(deps.storage, msg.denom)?; + + let _ = self.store_conn_sn(deps.storage, 0); + + self.store_signature_threshold(deps.storage, DEFAULT_SIGNATURE_THRESHOLD)?; + + Ok(Response::new() + .add_attribute("action", "instantiate") + .add_attribute("relayer", msg.relayer) + .add_attribute("xcall_address", msg.xcall_address)) + } + + pub fn set_admin( + &mut self, + deps: DepsMut, + info: MessageInfo, + address: Addr, + ) -> Result { + self.ensure_admin(deps.storage, info.sender)?; + let new_admin = deps.api.addr_validate(address.as_str())?; + let _ = self.store_admin(deps.storage, new_admin); + Ok(Response::new().add_attribute("action", "set_admin")) + } + + pub fn set_relayer( + &mut self, + deps: DepsMut, + info: MessageInfo, + address: Addr, + ) -> Result { + self.ensure_admin(deps.storage, info.sender)?; + let new_relayer = deps.api.addr_validate(address.as_str())?; + let _ = self.store_relayer(deps.storage, new_relayer); + Ok(Response::new().add_attribute("action", "set_relayer")) + } + + pub fn set_validators( + &mut self, + deps: DepsMut, + info: MessageInfo, + validators: Vec>, + threshold: u8, + ) -> Result { + self.ensure_admin(deps.storage, info.sender)?; + + if threshold < 1 { + return Err(ContractError::InvalidThreshold { + msg: "threshold should be at least 1".to_string(), + }); + } + + if !validators.is_empty() { + self.clear_validators(deps.storage)?; + for rlr in validators { + self.store_validator(deps.storage, rlr)?; + } + } + + let validators_set = self.get_validators(deps.storage)?; + + if validators_set.len() < threshold as usize { + return Err(ContractError::InvalidThreshold { + msg: "threshold should be at most the size of validators".to_string(), + }); + } + + self.store_signature_threshold(deps.storage, threshold)?; + + Ok(Response::new().add_attribute("action", "set_validators")) + } + + pub fn send_message( + &mut self, + deps: DepsMut, + info: MessageInfo, + to: NetId, + sn: i64, + msg: Vec, + ) -> Result { + self.ensure_xcall(deps.storage, info.sender)?; + + let next_conn_sn = self.get_next_conn_sn(deps.storage)?; + + let mut fee = 0; + + if sn >= 0 { + fee = self.get_fee(deps.storage, to.clone(), sn > 0)?.into(); + } + + let value = self.get_amount_for_denom(&info.funds, self.get_denom(deps.storage)); + + if fee > value { + return Err(ContractError::InsufficientFunds); + } + + Ok(Response::new() + .add_attribute("action", "send_message") + .add_event( + Event::new("Message") + .add_attribute("targetNetwork", to.to_string()) + .add_attribute("connSn", next_conn_sn.to_string()) + .add_attribute("msg", self.hex_encode(msg)), + )) + } + + pub fn set_signature_threshold( + &mut self, + deps: DepsMut, + info: MessageInfo, + threshold: u8, + ) -> Result { + self.ensure_admin(deps.storage, info.sender)?; + + self.store_signature_threshold(deps.storage, threshold)?; + + Ok(Response::new().add_attribute("action", "set_signature_threshold")) + } + + pub fn recv_message( + &mut self, + deps: DepsMut, + info: MessageInfo, + src_network: NetId, + conn_sn: u128, + msg: String, + signatures: Vec>, + ) -> Result { + self.ensure_relayer(deps.storage, info.sender)?; + + if self.get_receipt(deps.as_ref().storage, src_network.clone(), conn_sn) { + return Err(ContractError::DuplicateMessage); + } + + let dst_network = self.get_network_id(deps.as_ref())?; + + let msg_vec: Vec = self.hex_decode(msg)?; + + let signed_msg = SignableMsg { + src_network: src_network.to_string(), + conn_sn, + data: msg_vec.clone(), + dst_network: dst_network.to_string(), + }; + let signed_msg = signed_msg.encode_utf8_bytes().to_vec(); + + let threshold = self.get_signature_threshold(deps.storage); + + self.verify_signatures(deps.as_ref(), threshold, signed_msg, signatures)?; + + self.store_receipt(deps.storage, src_network.clone(), conn_sn)?; + + let xcall_submessage = + self.call_xcall_handle_message(deps.storage, &src_network, msg_vec)?; + + Ok(Response::new().add_submessage(xcall_submessage)) + } + + pub fn claim_fees( + &self, + deps: DepsMut, + env: Env, + info: MessageInfo, + ) -> Result { + self.ensure_relayer(deps.storage, info.sender)?; + let contract_balance = self.get_balance(&deps, env, self.get_denom(deps.storage)); + let msg = BankMsg::Send { + to_address: self.get_relayer(deps.storage)?.to_string(), + amount: coins(contract_balance, self.get_denom(deps.storage)), + }; + Ok(Response::new() + .add_attribute("action", "claim fees") + .add_message(msg)) + } + + pub fn set_fee( + &mut self, + deps: DepsMut, + info: MessageInfo, + network_id: NetId, + message_fee: u128, + response_fee: u128, + ) -> Result { + self.ensure_relayer(deps.storage, info.sender)?; + self.store_fee(deps.storage, network_id, message_fee, response_fee)?; + Ok(Response::new().add_attribute("action", "set_fee")) + } + + pub fn get_fee( + &self, + store: &dyn Storage, + network_id: NetId, + response: bool, + ) -> Result { + let mut fee = self.get_message_fee(store, network_id.clone()); + if response { + fee += self.get_response_fee(store, network_id); + } + Ok(fee.into()) + } + + pub fn migrate( + &self, + deps: DepsMut, + _env: Env, + _msg: MigrateMsg, + ) -> Result { + set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION) + .map_err(ContractError::Std)?; + Ok(Response::default().add_attribute("migrate", "successful")) + } +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/errors.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/errors.rs new file mode 100644 index 000000000..eba89f451 --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/errors.rs @@ -0,0 +1,33 @@ +use super::*; + +#[derive(Error, Debug)] +pub enum ContractError { + #[error("{0}")] + Std(#[from] StdError), + #[error("Unauthorized")] + Unauthorized {}, + #[error("Invalid Address {address}")] + InvalidAddress { address: String }, + #[error("Only Admin")] + OnlyAdmin, + #[error("Only Relayer")] + OnlyRelayer, + #[error("Only XCall")] + OnlyXCall, + #[error("Duplicate Message")] + DuplicateMessage, + #[error("InsufficientFunds")] + InsufficientFunds, + #[error("ERR_REPLY_ERROR|{code:?}|{msg:?}")] + ReplyError { code: u64, msg: String }, + #[error("Insufficient Signatures")] + InsufficientSignatures, + #[error("Invalid Signature")] + InvalidSignature, + + #[error("Invalid Hex Data|{msg:?}")] + InvalidHexData { msg: String }, + + #[error("Invalid Threshold Value|{msg:?}")] + InvalidThreshold { msg: String }, +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/helper.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/helper.rs new file mode 100644 index 000000000..6436a2efc --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/helper.rs @@ -0,0 +1,163 @@ +use std::{collections::HashMap, str::FromStr}; + +use cosmwasm_schema::QueryResponses; +use cosmwasm_std::{ensure_eq, Addr, BalanceResponse, BankQuery, Coin, QueryRequest}; +use cw_xcall_lib::network_address::{NetId, NetworkAddress}; +use sha2::Digest; +use sha3::Keccak256; + +use super::*; + +#[cw_serde] +#[derive(QueryResponses)] +pub enum XcallQueryMsg { + #[returns(String)] + GetNetworkAddress {}, +} + +pub fn keccak256(input: &[u8]) -> Keccak256 { + use sha3::{Digest, Keccak256}; + let mut hasher = Keccak256::new(); + hasher.update(input); + hasher +} + +impl<'a> ClusterConnection<'a> { + pub fn ensure_admin(&self, store: &dyn Storage, address: Addr) -> Result<(), ContractError> { + let admin = self.get_admin(store)?; + ensure_eq!(admin, address, ContractError::OnlyAdmin); + + Ok(()) + } + + pub fn ensure_relayer(&self, store: &dyn Storage, address: Addr) -> Result<(), ContractError> { + let relayer = self.get_relayer(store)?; + ensure_eq!(relayer, address, ContractError::OnlyRelayer); + + Ok(()) + } + + pub fn ensure_xcall(&self, store: &dyn Storage, address: Addr) -> Result<(), ContractError> { + let xcall = self.get_xcall(store)?; + ensure_eq!(xcall, address, ContractError::OnlyXCall); + + Ok(()) + } + + pub fn get_amount_for_denom(&self, funds: &Vec, target_denom: String) -> u128 { + for coin in funds.iter() { + if coin.denom == target_denom { + return coin.amount.into(); + } + } + 0 + } + + pub fn get_balance(&self, deps: &DepsMut, env: Env, denom: String) -> u128 { + let address = env.contract.address.to_string(); + let balance_query = BankQuery::Balance { denom, address }; + let balance_response: BalanceResponse = deps.querier.query(&balance_query.into()).unwrap(); + + balance_response.amount.amount.u128() + } + + pub fn hex_encode(&self, data: Vec) -> String { + if data.is_empty() { + "null".to_string() + } else { + hex::encode(data) + } + } + + pub fn hex_decode(&self, val: String) -> Result, ContractError> { + let hex_string_trimmed = val.trim_start_matches("0x"); + hex::decode(hex_string_trimmed) + .map_err(|e| ContractError::InvalidHexData { msg: e.to_string() }) + } + + pub fn get_network_id(&self, deps: Deps) -> Result { + let xcall_host = self.get_xcall(deps.storage)?; + + let query_msg = XcallQueryMsg::GetNetworkAddress {}; + + let query_request = QueryRequest::Wasm(cosmwasm_std::WasmQuery::Smart { + contract_addr: xcall_host.to_string(), + msg: to_json_binary(&query_msg).map_err(ContractError::Std)?, + }); + + let network_address: String = deps + .querier + .query(&query_request) + .map_err(ContractError::Std)?; + + Ok(NetworkAddress::from_str(network_address.as_str())? + .nid() + .to_string()) + } + + pub fn call_xcall_handle_message( + &self, + store: &dyn Storage, + nid: &NetId, + msg: Vec, + ) -> Result { + let xcall_host = self.get_xcall(store)?; + let xcall_msg = cw_xcall_lib::xcall_msg::ExecuteMsg::HandleMessage { + from_nid: nid.clone(), + msg, + }; + let call_message: CosmosMsg = CosmosMsg::Wasm(WasmMsg::Execute { + contract_addr: xcall_host.to_string(), + msg: to_json_binary(&xcall_msg).unwrap(), + funds: vec![], + }); + let sub_msg: SubMsg = SubMsg::new(call_message); + Ok(sub_msg) + } + + pub fn verify_signatures( + &self, + deps: Deps, + threshold: u8, + signed_msg: Vec, + signatures: Vec>, + ) -> Result<(), ContractError> { + if signatures.len() < threshold.into() { + return Err(ContractError::InsufficientSignatures); + } + + let message_hash = keccak256(&signed_msg).finalize().to_vec(); + + let mut signers: HashMap, bool> = HashMap::new(); + + for signature in signatures { + if signature.len() != 65 { + return Err(ContractError::InvalidSignature); + } + let mut recovery_code = signature[64]; + if recovery_code >= 27 { + recovery_code -= 27; + } + match deps + .api + .secp256k1_recover_pubkey(&message_hash, &signature[0..64], recovery_code) + { + Ok(pubkey) => { + if self.is_validator(deps.storage, pubkey.clone()) + && !signers.contains_key(&pubkey) + { + signers.insert(pubkey, true); + if signers.len() >= threshold.into() { + return Ok(()); + } + } + } + Err(e) => { + continue; + } + } + } + + Err(ContractError::InsufficientSignatures) + } +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/lib.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/lib.rs new file mode 100644 index 000000000..913d5bbe1 --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/lib.rs @@ -0,0 +1,114 @@ +pub mod contract; +pub mod errors; +pub mod helper; +pub mod msg; +pub mod state; +pub mod types; + +use cosmwasm_schema::cw_serde; +use cosmwasm_std::{ + entry_point, to_json_binary, Binary, CosmosMsg, Deps, DepsMut, Empty, Env, MessageInfo, + Response, StdError, StdResult, Storage, SubMsg, WasmMsg, +}; + +use cw2::set_contract_version; +use cw_storage_plus::{Item, Map}; +pub use errors::*; +pub use helper::*; +use msg::{ExecuteMsg, MigrateMsg, QueryMsg}; +use state::ClusterConnection; +use thiserror::Error; +pub use types::*; + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn instantiate( + deps: DepsMut, + env: Env, + info: MessageInfo, + msg: InstantiateMsg, +) -> Result { + let mut conn = ClusterConnection::default(); + conn.instantiate(deps, env, info, msg) +} + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn execute( + deps: DepsMut, + env: Env, + info: MessageInfo, + msg: ExecuteMsg, +) -> Result { + let mut conn = ClusterConnection::default(); + match msg { + ExecuteMsg::SetAdmin { address } => conn.set_admin(deps, info, address), + + ExecuteMsg::SetRelayer { address } => conn.set_relayer(deps, info, address), + + ExecuteMsg::SetValidators { + validators, + threshold, + } => conn.set_validators(deps, info, validators, threshold), + + ExecuteMsg::SetSignatureThreshold { threshold } => { + conn.set_signature_threshold(deps, info, threshold) + } + + ExecuteMsg::SetFee { + network_id, + message_fee, + response_fee, + } => conn.set_fee(deps, info, network_id, message_fee, response_fee), + + ExecuteMsg::ClaimFees {} => conn.claim_fees(deps, env, info), + + ExecuteMsg::SendMessage { to, sn, msg } => conn.send_message(deps, info, to, sn, msg), + + ExecuteMsg::RecvMessage { + src_network, + conn_sn, + msg, + signatures, + } => conn.recv_message(deps, info, src_network, conn_sn, msg, signatures), + } +} + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult { + let conn = ClusterConnection::default(); + match msg { + QueryMsg::GetFee { nid, response } => { + to_json_binary(&conn.get_fee(deps.storage, nid, response).unwrap()) + } + + QueryMsg::GetReceipt { + src_network, + conn_sn, + } => to_json_binary(&conn.get_receipt(deps.storage, src_network, conn_sn)), + + QueryMsg::GetAdmin {} => { + let admin = conn.get_admin(deps.storage).unwrap(); + to_json_binary(&admin) + } + + QueryMsg::GetRelayer {} => { + let relayer = conn.get_relayer(deps.storage).unwrap(); + to_json_binary(&relayer) + } + + QueryMsg::GetValidators {} => { + let validators = conn.get_validators(deps.storage)?; + to_json_binary(&validators) + } + + QueryMsg::GetSignatureThreshold {} => { + let threshold = conn.get_signature_threshold(deps.storage); + to_json_binary(&threshold) + } + } +} + +#[cfg_attr(not(feature = "library"), entry_point)] +pub fn migrate(deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result { + let conn = ClusterConnection::default(); + conn.migrate(deps, _env, _msg) +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/msg.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/msg.rs new file mode 100644 index 000000000..1b4f2895d --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/msg.rs @@ -0,0 +1,69 @@ +use cosmwasm_schema::{cw_serde, QueryResponses}; +use cosmwasm_std::Addr; +use cw_xcall_lib::network_address::NetId; + +#[cw_serde] +pub enum ExecuteMsg { + SetAdmin { + address: Addr, + }, + + SetRelayer { + address: Addr, + }, + + SetValidators { + validators: Vec>, + threshold: u8, + }, + + SetSignatureThreshold { + threshold: u8, + }, + + SetFee { + network_id: NetId, + message_fee: u128, + response_fee: u128, + }, + + ClaimFees {}, + + SendMessage { + to: NetId, + sn: i64, + msg: Vec, + }, + + RecvMessage { + src_network: NetId, + conn_sn: u128, + msg: String, + signatures: Vec>, + }, +} + +#[cw_serde] +#[derive(QueryResponses)] +pub enum QueryMsg { + #[returns(u64)] + GetFee { nid: NetId, response: bool }, + + #[returns(bool)] + GetReceipt { src_network: NetId, conn_sn: u128 }, + + #[returns(Addr)] + GetAdmin {}, + + #[returns(Addr)] + GetRelayer {}, + + #[returns(Vec)] + GetValidators {}, + + #[returns(u16)] + GetSignatureThreshold {}, +} + +#[cw_serde] +pub struct MigrateMsg {} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/state.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/state.rs new file mode 100644 index 000000000..07a39bf2b --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/state.rs @@ -0,0 +1,188 @@ +use cosmwasm_std::Addr; +use cw_xcall_lib::network_address::NetId; + +use crate::types::StorageKey; + +use super::*; + +pub struct ClusterConnection<'a> { + xcall: Item<'a, Addr>, + admin: Item<'a, Addr>, + relayer: Item<'a, Addr>, + validators: Map<'a, Vec, bool>, + signature_threshold: Item<'a, u8>, + + message_fee: Map<'a, NetId, u128>, + response_fee: Map<'a, NetId, u128>, + + conn_sn: Item<'a, u128>, + receipts: Map<'a, (String, u128), bool>, + + denom: Item<'a, String>, +} + +impl<'a> Default for ClusterConnection<'a> { + fn default() -> Self { + Self::new() + } +} + +impl<'a> ClusterConnection<'a> { + pub fn new() -> Self { + Self { + xcall: Item::new(StorageKey::XCall.as_str()), + admin: Item::new(StorageKey::Admin.as_str()), + relayer: Item::new(StorageKey::Relayer.as_str()), + validators: Map::new(StorageKey::Validators.as_str()), + signature_threshold: Item::new(StorageKey::SignatureThreshold.as_str()), + + message_fee: Map::new(StorageKey::MessageFee.as_str()), + response_fee: Map::new(StorageKey::ResponseFee.as_str()), + + conn_sn: Item::new(StorageKey::ConnSn.as_str()), + receipts: Map::new(StorageKey::Receipts.as_str()), + + denom: Item::new(StorageKey::Denom.as_str()), + } + } + + pub fn store_xcall(&mut self, store: &mut dyn Storage, address: Addr) -> StdResult<()> { + self.xcall.save(store, &address)?; + Ok(()) + } + + pub fn get_xcall(&self, store: &dyn Storage) -> Result { + Ok(self.xcall.load(store)?) + } + + pub fn store_admin(&mut self, store: &mut dyn Storage, address: Addr) -> StdResult<()> { + self.admin.save(store, &address)?; + Ok(()) + } + + pub fn get_admin(&self, store: &dyn Storage) -> Result { + Ok(self.admin.load(store)?) + } + + pub fn store_relayer(&mut self, store: &mut dyn Storage, address: Addr) -> StdResult<()> { + self.relayer.save(store, &address)?; + Ok(()) + } + + pub fn get_relayer(&self, store: &dyn Storage) -> Result { + Ok(self.relayer.load(store)?) + } + + pub fn store_conn_sn(&mut self, store: &mut dyn Storage, sn: u128) -> StdResult<()> { + self.conn_sn.save(store, &sn)?; + Ok(()) + } + + pub fn get_next_conn_sn(&self, store: &mut dyn Storage) -> Result { + let mut connsn = self.conn_sn.load(store).unwrap_or(0); + connsn += 1; + self.conn_sn.save(store, &connsn)?; + Ok(connsn) + } + + pub fn store_fee( + &mut self, + store: &mut dyn Storage, + to: NetId, + message_fee: u128, + response_fee: u128, + ) -> StdResult<()> { + self.message_fee.save(store, to.clone(), &message_fee)?; + self.response_fee.save(store, to, &response_fee)?; + Ok(()) + } + pub fn get_message_fee(&self, store: &dyn Storage, to: NetId) -> u128 { + self.message_fee.load(store, to).unwrap_or(0) + } + + pub fn get_response_fee(&self, store: &dyn Storage, to: NetId) -> u128 { + self.response_fee.load(store, to).unwrap_or(0) + } + + pub fn store_receipt( + &mut self, + store: &mut dyn Storage, + src_network: NetId, + connsn: u128, + ) -> StdResult<()> { + self.receipts + .save(store, (src_network.to_string(), connsn), &true)?; + Ok(()) + } + + pub fn get_receipt(&self, store: &dyn Storage, src_network: NetId, sn: u128) -> bool { + self.receipts + .load(store, (src_network.to_string(), sn)) + .unwrap_or(false) + } + + pub fn store_denom(&mut self, store: &mut dyn Storage, denom: String) -> StdResult<()> { + self.denom.save(store, &denom)?; + Ok(()) + } + + pub fn get_denom(&self, store: &dyn Storage) -> String { + self.denom.load(store).unwrap() + } + + pub fn store_validator( + &mut self, + store: &mut dyn Storage, + validator: Vec, + ) -> StdResult<()> { + self.validators.save(store, validator, &true)?; + Ok(()) + } + + pub fn remove_validator( + &mut self, + store: &mut dyn Storage, + validator: Vec, + ) -> StdResult<()> { + self.validators.remove(store, validator); + Ok(()) + } + + pub fn clear_validators(&mut self, store: &mut dyn Storage) -> StdResult<()> { + self.validators.clear(store); + Ok(()) + } + + pub fn get_validators(&self, store: &dyn Storage) -> StdResult> { + let mut validators_list: Vec = Vec::new(); + let validators_iter = + self.validators + .range(store, None, None, cosmwasm_std::Order::Ascending); + + for item in validators_iter { + let (validator_addr, is_active) = item?; + if is_active { + validators_list.push(hex::encode(validator_addr)); + } + } + + Ok(validators_list) + } + + pub fn is_validator(&self, store: &dyn Storage, pub_key: Vec) -> bool { + self.validators.has(store, pub_key) + } + + pub fn store_signature_threshold( + &mut self, + store: &mut dyn Storage, + threshold: u8, + ) -> StdResult<()> { + self.signature_threshold.save(store, &threshold)?; + Ok(()) + } + + pub fn get_signature_threshold(&self, store: &dyn Storage) -> u8 { + self.signature_threshold.load(store).unwrap() + } +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/src/types.rs b/contracts/cosmwasm-vm/cw-cluster-connection/src/types.rs new file mode 100644 index 000000000..0457d8fa1 --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/src/types.rs @@ -0,0 +1,86 @@ +use super::*; + +#[cw_serde] +pub struct InstantiateMsg { + pub relayer: String, + pub xcall_address: String, + pub denom: String, +} + +#[cw_serde] +pub enum StorageKey { + XCall, + Admin, + Relayer, + Validators, + SignatureThreshold, + + MessageFee, + ResponseFee, + + ConnSn, + Receipts, + + Denom, +} + +impl StorageKey { + pub fn as_str(&self) -> &'static str { + match self { + StorageKey::XCall => "xcall", + StorageKey::Admin => "admin", + StorageKey::Relayer => "relayer", + StorageKey::Validators => "validators", + StorageKey::SignatureThreshold => "signature_threshold", + + StorageKey::MessageFee => "message_fee", + StorageKey::ResponseFee => "response_fee", + + StorageKey::ConnSn => "conn_sn", + StorageKey::Receipts => "receipts", + + StorageKey::Denom => "denom", + } + } +} + +pub struct SignableMsg { + pub src_network: String, + pub conn_sn: u128, + pub data: Vec, + pub dst_network: String, +} +impl SignableMsg { + pub fn encode_utf8_bytes(&self) -> Vec { + let mut encoded_bytes = Vec::new(); + + encoded_bytes.extend(self.src_network.as_bytes()); + + encoded_bytes.extend(self.conn_sn.to_string().as_bytes()); + + encoded_bytes.extend(self.data.to_vec()); + + encoded_bytes.extend(self.dst_network.as_bytes()); + + encoded_bytes + } +} + +#[test] +pub fn test_signable_msg_utf8_bytes() { + let signed_msg = SignableMsg { + src_network: "0x2.icon".to_string(), + conn_sn: 128, + data: "hello".as_bytes().to_vec(), + dst_network: "archway".to_string(), + }; + + let expected_encoded_hex_str = "3078322e69636f6e31323868656c6c6f61726368776179".to_string(); + let expected_encoded_bytes = hex::decode(expected_encoded_hex_str).unwrap(); + + assert_eq!( + expected_encoded_bytes, + signed_msg.encode_utf8_bytes(), + "test failed" + ); +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/tests/setup.rs b/contracts/cosmwasm-vm/cw-cluster-connection/tests/setup.rs new file mode 100644 index 000000000..42b4cf97f --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/tests/setup.rs @@ -0,0 +1,14 @@ +use cosmwasm_std::{ + coins, + testing::{mock_dependencies, mock_info, MockApi, MockQuerier, MockStorage}, + Empty, MessageInfo, OwnedDeps, +}; + +pub fn create_mock_info(creator: &str, denom: &str, amount: u128) -> MessageInfo { + let funds = coins(amount, denom); + mock_info(creator, &funds) +} + +pub fn deps() -> OwnedDeps { + mock_dependencies() +} diff --git a/contracts/cosmwasm-vm/cw-cluster-connection/tests/test.rs b/contracts/cosmwasm-vm/cw-cluster-connection/tests/test.rs new file mode 100644 index 000000000..2bd9bb5b8 --- /dev/null +++ b/contracts/cosmwasm-vm/cw-cluster-connection/tests/test.rs @@ -0,0 +1,569 @@ +pub mod setup; +use cluster_connection::{ + execute, msg::ExecuteMsg, state::ClusterConnection, types::InstantiateMsg, +}; +use cluster_connection::{keccak256, SignableMsg}; +use cosmwasm_std::{testing::mock_env, ContractResult, Env}; +use cosmwasm_std::{ + testing::{mock_dependencies, mock_info, MockApi, MockQuerier}, + Addr, MemoryStorage, OwnedDeps, Uint128, +}; +use cosmwasm_std::{to_json_binary, Coin, ContractInfoResponse, Event, SystemResult, WasmQuery}; +use cw_xcall_lib::network_address::NetId; +use k256::{ecdsa::SigningKey, ecdsa::VerifyingKey, elliptic_curve::rand_core::OsRng}; +use std::str::FromStr; + +const XCALL: &str = "xcall"; +const DENOM: &str = "denom"; +const ADMIN: &str = "admin"; +const RELAYER: &str = "relayer"; + +fn instantiate( + sender: &str, +) -> ( + OwnedDeps, + Env, + ClusterConnection<'_>, +) { + let mut deps: OwnedDeps = mock_dependencies(); + let mut ctx: ClusterConnection<'_> = ClusterConnection::default(); + let env = mock_env(); + let info = mock_info(sender, &[]); + let msg = InstantiateMsg { + relayer: RELAYER.to_string(), + xcall_address: XCALL.to_string(), + denom: DENOM.to_string(), + }; + let res = ctx.instantiate(deps.as_mut(), env.clone(), info, msg); + assert!(res.is_ok()); + + (deps, env, ctx) +} + +#[test] +fn test_initialization() { + instantiate(ADMIN); +} + +#[test] +fn test_set_admin() { + let (mut deps, env, ctx) = instantiate(ADMIN); + let msg_info = mock_info(ADMIN, &[]); + + let new_admin = Addr::unchecked("new_admin"); + let msg = ExecuteMsg::SetAdmin { + address: new_admin.clone(), + }; + + let res = execute(deps.as_mut(), env, msg_info, msg); + assert!(res.is_ok()); + + let admin = ctx.get_admin(deps.as_mut().storage).unwrap(); + assert_eq!(admin, new_admin); +} + +#[test] +fn test_set_admin_unauthorized() { + let (mut deps, env, ctx) = instantiate(ADMIN); + let msg_info = mock_info("UnathorizedUser", &[]); + + let new_admin = Addr::unchecked("new_admin"); + let msg = ExecuteMsg::SetAdmin { + address: new_admin.clone(), + }; + + let res = execute(deps.as_mut(), env, msg_info, msg); + assert!(res.is_err()); + assert_eq!("Only Admin", res.unwrap_err().to_string()); +} + +#[test] +fn test_set_relayer() { + let (mut deps, env, ctx) = instantiate(ADMIN); + let msg_info = mock_info(ADMIN, &[]); + + let new_relayer = Addr::unchecked("new_relayer"); + let msg = ExecuteMsg::SetRelayer { + address: new_relayer.clone(), + }; + + let res = execute(deps.as_mut(), env, msg_info, msg); + assert!(res.is_ok()); + + let relayer = ctx.get_relayer(deps.as_mut().storage).unwrap(); + assert_eq!(relayer, new_relayer); +} + +#[test] +fn test_set_relayer_unauthorized() { + let (mut deps, env, ctx) = instantiate(ADMIN); + let msg_info = mock_info("UnathorizedUser", &[]); + + let new_relayer = Addr::unchecked("new_relayer"); + let msg = ExecuteMsg::SetRelayer { + address: new_relayer.clone(), + }; + + let res = execute(deps.as_mut(), env, msg_info, msg); + assert!(res.is_err()); + assert_eq!("Only Admin", res.unwrap_err().to_string()); +} + +#[test] +pub fn test_set_validators() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let val1 = "02e27e3817bf0b6d451004609c2a5d29fe315dc1d1017500399fab540785958b7a"; + let val2 = "03ea8d2913ce5bb5637fe732f920ccee7a454a8f1c32a531e7abc1a58a23cc8db0"; + let val3 = "03cc5598f8f40103592b6ed9e04adcf9bd67fe06d677bf5b392af0ad9b553a5b16"; + let validators = vec![ + hex::decode(val1).unwrap(), + hex::decode(val2).unwrap(), + hex::decode(val3).unwrap(), + ]; + + let threshold = 2; + + let msg = ExecuteMsg::SetValidators { + validators, + threshold, + }; + + let info = mock_info(ADMIN, &[]); + let res = execute(deps.as_mut(), env.clone(), info, msg.clone()); + assert!(res.is_ok()); + + let mut stored_validators = ctx.get_validators(deps.as_ref().storage).unwrap(); + let mut set_validators = [val1.to_string(), val2.to_string(), val3.to_string()]; + + assert_eq!(stored_validators.sort(), set_validators.sort()); + + let stored_threshold = ctx.get_signature_threshold(deps.as_ref().storage); + assert_eq!(stored_threshold, threshold); +} + +#[test] +pub fn test_set_validators_unauthorized() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let val1 = "02e27e3817bf0b6d451004609c2a5d29fe315dc1d1017500399fab540785958b7a"; + let val2 = "03ea8d2913ce5bb5637fe732f920ccee7a454a8f1c32a531e7abc1a58a23cc8db0"; + let val3 = "03cc5598f8f40103592b6ed9e04adcf9bd67fe06d677bf5b392af0ad9b553a5b16"; + let validators = vec![ + hex::decode(val1).unwrap(), + hex::decode(val2).unwrap(), + hex::decode(val3).unwrap(), + ]; + + let threshold = 2; + + let msg = ExecuteMsg::SetValidators { + validators: validators.clone(), + threshold, + }; + + let info = mock_info("UnauthorisedUser", &[]); + let res = execute(deps.as_mut(), env.clone(), info, msg.clone()); + assert!(res.is_err()); + assert_eq!("Only Admin", res.unwrap_err().to_string()); +} + +#[test] +pub fn test_set_validators_empty() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let val1 = "02e27e3817bf0b6d451004609c2a5d29fe315dc1d1017500399fab540785958b7a"; + let val2 = "03ea8d2913ce5bb5637fe732f920ccee7a454a8f1c32a531e7abc1a58a23cc8db0"; + let val3 = "03cc5598f8f40103592b6ed9e04adcf9bd67fe06d677bf5b392af0ad9b553a5b16"; + let validators = vec![ + hex::decode(val1).unwrap(), + hex::decode(val2).unwrap(), + hex::decode(val3).unwrap(), + ]; + + let info = mock_info(ADMIN, &[]); + let res = execute( + deps.as_mut(), + env.clone(), + info.clone(), + ExecuteMsg::SetValidators { + validators: validators.clone(), + threshold: 2, + }, + ); + assert!(res.is_ok()); + + let res = execute( + deps.as_mut(), + env.clone(), + info, + ExecuteMsg::SetValidators { + validators: vec![], + threshold: 2, + }, + ); + assert!(res.is_ok()); + + let mut stored_validators = ctx.get_validators(deps.as_ref().storage).unwrap(); + let stored_threshold = ctx.get_signature_threshold(deps.as_ref().storage); + + let mut set_validators = [val1.to_string(), val2.to_string(), val3.to_string()]; + assert_eq!(set_validators.sort(), stored_validators.sort()); + + assert_eq!(stored_threshold, 2); +} + +#[test] +pub fn test_set_validators_invalid_threshold() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let val1 = "02e27e3817bf0b6d451004609c2a5d29fe315dc1d1017500399fab540785958b7a"; + let val2 = "03ea8d2913ce5bb5637fe732f920ccee7a454a8f1c32a531e7abc1a58a23cc8db0"; + let val3 = "03cc5598f8f40103592b6ed9e04adcf9bd67fe06d677bf5b392af0ad9b553a5b16"; + let validators = vec![ + hex::decode(val1).unwrap(), + hex::decode(val2).unwrap(), + hex::decode(val3).unwrap(), + ]; + + let info = mock_info(ADMIN, &[]); + let res = execute( + deps.as_mut(), + env.clone(), + info.clone(), + ExecuteMsg::SetValidators { + validators: validators.clone(), + threshold: 0, + }, + ); + assert!(res.is_err()); + + let res = execute( + deps.as_mut(), + env.clone(), + info, + ExecuteMsg::SetValidators { + validators: vec![], + threshold: 4, + }, + ); + assert!(res.is_err()); +} + +#[test] +fn test_set_fee() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let nid = NetId::from_str("0x2.icon").unwrap(); + let message_fee: u128 = 200; + let response_fee: u128 = 100; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + ExecuteMsg::SetFee { + network_id: nid.clone(), + message_fee, + response_fee, + }, + ); + assert!(res.is_ok()); + + let res = ctx + .get_fee(deps.as_mut().storage, nid.clone(), false) + .unwrap(); + assert_eq!(res, Uint128::from(message_fee)); + + let res = ctx.get_fee(deps.as_mut().storage, nid, true).unwrap(); + assert_eq!(res, Uint128::from(message_fee + response_fee)); +} + +#[test] +fn test_set_fee_unauthorized() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + let nid = NetId::from_str("0x2.icon").unwrap(); + let message_fee: u128 = 200; + let response_fee: u128 = 100; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info("UnauthorisedUser", &[]), + ExecuteMsg::SetFee { + network_id: nid.clone(), + message_fee, + response_fee, + }, + ); + assert!(res.is_err()); + assert_eq!("Only Relayer", res.unwrap_err().to_string()); +} + +#[test] +pub fn test_claim_fees() { + let (mut deps, env, _ctx) = instantiate(ADMIN); + + let nid = NetId::from_str("0x2.icon").unwrap(); + let message_fee: u128 = 200; + let response_fee: u128 = 100; + + let amount: u128 = 200; + let coin: Coin = Coin { + denom: DENOM.to_string(), + amount: Uint128::from(amount), + }; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + ExecuteMsg::SetFee { + network_id: nid.clone(), + message_fee, + response_fee, + }, + ); + assert!(res.is_ok()); + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(XCALL, &[coin.clone()]), + ExecuteMsg::SendMessage { + to: nid, + sn: 0, + msg: vec![], + }, + ); + assert!(res.is_ok()); + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + ExecuteMsg::ClaimFees {}, + ); + assert!(res.is_ok()); +} + +#[test] +pub fn test_send_message() { + let (mut deps, env, _ctx) = instantiate(ADMIN); + let msg = ExecuteMsg::SendMessage { + to: NetId::from_str("nid").unwrap(), + sn: 0, + msg: vec![], + }; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(XCALL, &[]), + msg.clone(), + ); + + assert!(res.is_ok()); + let event = Event::new("Message") + .add_attribute("targetNetwork", "nid") + .add_attribute("connSn", 1.to_string()) + .add_attribute("msg", "null"); + assert_eq!(res.unwrap().events[0], event); +} + +#[test] +pub fn test_send_message_unauthorized() { + let (mut deps, env, _ctx) = instantiate(ADMIN); + let msg = ExecuteMsg::SendMessage { + to: NetId::from_str("nid").unwrap(), + sn: 0, + msg: vec![], + }; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + msg.clone(), + ); + + assert!(res.is_err()); + + assert_eq!("Only XCall", res.unwrap_err().to_string()); +} + +#[test] +pub fn test_recv_message() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + deps.querier.update_wasm(|r: &WasmQuery| match r { + WasmQuery::Smart { + contract_addr: _, + msg: _, + } => SystemResult::Ok(ContractResult::Ok(to_json_binary("archway/xcall").unwrap())), + WasmQuery::ContractInfo { contract_addr: _ } => SystemResult::Ok(ContractResult::Ok( + to_json_binary(&ContractInfoResponse::default()).unwrap(), + )), + _ => todo!(), + }); + + let src_network = NetId::from_str("0x2.icon").unwrap(); + let dst_network = NetId::from_str("archway").unwrap(); + let conn_sn: u128 = 456456; + let msg = string_to_hex("hello"); + + let signed_msg = SignableMsg { + src_network: src_network.to_string(), + conn_sn, + data: hex::decode(msg.clone()).unwrap(), + dst_network: dst_network.to_string(), + }; + let signed_msg = signed_msg.encode_utf8_bytes().to_vec(); + let message_digest = keccak256(&signed_msg); + + let signing_key = SigningKey::random(&mut OsRng); + let verifying_key = VerifyingKey::from(&signing_key); + let pubkey = verifying_key.to_encoded_point(false).as_bytes().to_vec(); + let (signature, recovery_code) = signing_key + .sign_digest_recoverable(message_digest.clone()) + .unwrap(); + let mut sign_0 = signature.to_vec(); + sign_0.push(recovery_code.to_byte()); + + let signing_key_1 = SigningKey::random(&mut OsRng); + let verifying_key_1 = VerifyingKey::from(&signing_key_1); + let pubkey_1 = verifying_key_1.to_encoded_point(false).as_bytes().to_vec(); + let (signature_1, recovery_code_1) = signing_key_1 + .sign_digest_recoverable(message_digest.clone()) + .unwrap(); + let mut sign_1 = signature_1.to_vec(); + sign_1.push(recovery_code_1.to_byte()); + + let validators = vec![pubkey.clone(), pubkey_1.clone()]; + + let set_validators_msg = ExecuteMsg::SetValidators { + validators: validators.clone(), + threshold: 2, + }; + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(ADMIN, &[]), + set_validators_msg, + ); + assert!(res.is_ok()); + + let signatures = vec![sign_1, sign_0]; + + // Test with non-relayer sender (should fail) + let msg_with_signatures = ExecuteMsg::RecvMessage { + src_network: src_network.clone(), + conn_sn, + msg, + signatures: signatures.clone(), + }; + let res = execute( + deps.as_mut(), + env.clone(), + mock_info("WHO AM I", &[]), + msg_with_signatures.clone(), + ); + assert!(res.is_err()); + assert_eq!("Only Relayer", res.unwrap_err().to_string()); + + // Test with relayer sender (should succeed) + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + msg_with_signatures.clone(), + ); + assert!(res.is_ok()); + + // Verify that the message was received (check receipt) + let receipt = ctx.get_receipt(deps.as_ref().storage, src_network.clone(), conn_sn); + assert!(receipt); +} + +#[test] +pub fn test_recv_message_signatures_insufficient() { + let (mut deps, env, ctx) = instantiate(ADMIN); + + deps.querier.update_wasm(|r: &WasmQuery| match r { + WasmQuery::Smart { + contract_addr: _, + msg: _, + } => SystemResult::Ok(ContractResult::Ok(to_json_binary("archway/xcall").unwrap())), + WasmQuery::ContractInfo { contract_addr: _ } => SystemResult::Ok(ContractResult::Ok( + to_json_binary(&ContractInfoResponse::default()).unwrap(), + )), + _ => todo!(), + }); + + let src_network = NetId::from_str("0x2.icon").unwrap(); + let dst_network = NetId::from_str("archway").unwrap(); + let conn_sn: u128 = 456456; + let msg = string_to_hex("hello"); + + let signed_msg = SignableMsg { + src_network: src_network.to_string(), + conn_sn, + data: hex::decode(msg.clone()).unwrap(), + dst_network: dst_network.to_string(), + }; + let signed_msg = signed_msg.encode_utf8_bytes().to_vec(); + let message_digest = keccak256(&signed_msg); + + let signing_key = SigningKey::random(&mut OsRng); + + let verifying_key = VerifyingKey::from(&signing_key); + let pubkey = verifying_key.to_encoded_point(false).as_bytes().to_vec(); + + let (signature, recovery_code) = signing_key.sign_digest_recoverable(message_digest).unwrap(); + + let mut sign_1 = signature.to_vec(); + sign_1.push(recovery_code.to_byte()); + + let val2 = "03ea8d2913ce5bb5637fe732f920ccee7a454a8f1c32a531e7abc1a58a23cc8db0"; + let validators = vec![pubkey, hex::decode(val2).unwrap()]; + + let set_validators_msg = ExecuteMsg::SetValidators { + validators: validators.clone(), + threshold: 2, + }; + let resp = execute( + deps.as_mut(), + env.clone(), + mock_info(ADMIN, &[]), + set_validators_msg, + ); + assert!(resp.is_ok()); + + let signatures = vec![sign_1]; + + let msg_with_signatures = ExecuteMsg::RecvMessage { + src_network: src_network.clone(), + conn_sn, + msg, + signatures: signatures.clone(), + }; + + let res = execute( + deps.as_mut(), + env.clone(), + mock_info(RELAYER, &[]), + msg_with_signatures.clone(), + ); + println!("response: {:?}", res); + assert!(res.is_err()); + assert_eq!("Insufficient Signatures", res.unwrap_err().to_string()); +} + +fn string_to_hex(input: &str) -> String { + input + .as_bytes() + .iter() + .map(|b| format!("{:02x}", b)) + .collect() +} diff --git a/contracts/cosmwasm-vm/cw-xcall/src/types/request.rs b/contracts/cosmwasm-vm/cw-xcall/src/types/request.rs index 699970595..b6ceef96b 100644 --- a/contracts/cosmwasm-vm/cw-xcall/src/types/request.rs +++ b/contracts/cosmwasm-vm/cw-xcall/src/types/request.rs @@ -168,7 +168,7 @@ mod tests { */ - use std::{io::Read, str::FromStr}; + use std::str::FromStr; use common::rlp::{self, RlpStream}; use cosmwasm_std::Addr; diff --git a/contracts/evm/cache/solidity-files-cache.json b/contracts/evm/cache/solidity-files-cache.json index 8293f38d8..fda164485 100644 --- a/contracts/evm/cache/solidity-files-cache.json +++ b/contracts/evm/cache/solidity-files-cache.json @@ -1 +1 @@ -{"_format":"ethers-rs-sol-cache-3","paths":{"artifacts":"out","build_infos":"out/build-info","sources":"contracts","tests":"test","scripts":"script","libraries":["lib"]},"files":{"contracts/adapters/CentralizedConnection.sol":{"lastModificationDate":1714578796610,"contentHash":"5d955f6e51b9a2148459f809272443ae","sourceName":"contracts/adapters/CentralizedConnection.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"CentralizedConnection":{"0.8.23+commit.f704f362.Linux.gcc":"CentralizedConnection.sol/CentralizedConnection.json"}}},"contracts/adapters/LayerZeroAdapter.sol":{"lastModificationDate":1714578796610,"contentHash":"d094a841c17d3f15f779e8278d491b43","sourceName":"contracts/adapters/LayerZeroAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"LayerZeroAdapter":{"0.8.23+commit.f704f362.Linux.gcc":"LayerZeroAdapter.sol/LayerZeroAdapter.json"}}},"contracts/adapters/WormholeAdapter.sol":{"lastModificationDate":1714578796610,"contentHash":"b83f9cae20556e583a62067d3ee83ef2","sourceName":"contracts/adapters/WormholeAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"WormholeAdapter":{"0.8.23+commit.f704f362.Linux.gcc":"WormholeAdapter.sol/WormholeAdapter.json"}}},"contracts/adapters/interfaces/ILayerZeroAdapter.sol":{"lastModificationDate":1714578796610,"contentHash":"f50709b9cbce46fbef763fb493f1241a","sourceName":"contracts/adapters/interfaces/ILayerZeroAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ILayerZeroAdapter":{"0.8.23+commit.f704f362.Linux.gcc":"ILayerZeroAdapter.sol/ILayerZeroAdapter.json"}}},"contracts/adapters/interfaces/IWormholeAdapter.sol":{"lastModificationDate":1714578796610,"contentHash":"a712c7736208ffbf1a7b6b3daac0ae02","sourceName":"contracts/adapters/interfaces/IWormholeAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IWormholeAdapter":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeAdapter.sol/IWormholeAdapter.json"}}},"contracts/mocks/dapp/DAppProxySample.sol":{"lastModificationDate":1714578796610,"contentHash":"24e6a3a7cf297bd769df8649a6bd5540","sourceName":"contracts/mocks/dapp/DAppProxySample.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol"],"versionRequirement":">=0.8.0","artifacts":{"DAppProxySample":{"0.8.23+commit.f704f362.Linux.gcc":"DAppProxySample.sol/DAppProxySample.json"}}},"contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol":{"lastModificationDate":1714578796610,"contentHash":"70f440bba0a2f34f25b7b1afb19d670f","sourceName":"contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"MultiProtocolSampleDapp":{"0.8.23+commit.f704f362.Linux.gcc":"MultiProtocolSampleDapp.sol/MultiProtocolSampleDapp.json"}}},"contracts/xcall/CallService.sol":{"lastModificationDate":1714578796620,"contentHash":"bf685d26120eda151678e379f4c91390","sourceName":"contracts/xcall/CallService.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.0","artifacts":{"CallService":{"0.8.23+commit.f704f362.Linux.gcc":"CallService.sol/CallService.json"}}},"contracts/xcall/CallServiceV1.sol":{"lastModificationDate":1714578796620,"contentHash":"1ade36fba8cd84927086fa52d2f988ec","sourceName":"contracts/xcall/CallServiceV1.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/ICallServiceV1.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.0","artifacts":{"CallServiceV1":{"0.8.23+commit.f704f362.Linux.gcc":"CallServiceV1.sol/CallServiceV1.json"}}},"contracts/xcall/interfaces/IConnection.sol":{"lastModificationDate":1714578796620,"contentHash":"c0ee93405e30cbc20c985981aec534b7","sourceName":"contracts/xcall/interfaces/IConnection.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IConnection":{"0.8.23+commit.f704f362.Linux.gcc":"IConnection.sol/IConnection.json"}}},"contracts/xcall/interfaces/IFeeManage.sol":{"lastModificationDate":1714578796620,"contentHash":"98dba095babc43947dce1d0b28cd8c55","sourceName":"contracts/xcall/interfaces/IFeeManage.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IFeeManage":{"0.8.23+commit.f704f362.Linux.gcc":"IFeeManage.sol/IFeeManage.json"}}},"lib/forge-std/lib/ds-test/src/test.sol":{"lastModificationDate":1714580985869,"contentHash":"9febff9d09f18af5306669dc276c4c43","sourceName":"lib/forge-std/lib/ds-test/src/test.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"DSTest":{"0.8.23+commit.f704f362.Linux.gcc":"test.sol/DSTest.json"}}},"lib/forge-std/src/Base.sol":{"lastModificationDate":1714580983859,"contentHash":"ee13c050b1914464f1d3f90cde90204b","sourceName":"lib/forge-std/src/Base.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/StdStorage.sol","lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"CommonBase":{"0.8.23+commit.f704f362.Linux.gcc":"Base.sol/CommonBase.json"},"ScriptBase":{"0.8.23+commit.f704f362.Linux.gcc":"Base.sol/ScriptBase.json"},"TestBase":{"0.8.23+commit.f704f362.Linux.gcc":"Base.sol/TestBase.json"}}},"lib/forge-std/src/Script.sol":{"lastModificationDate":1714580983859,"contentHash":"ba325c778a7da8a21c2136aa32763c14","sourceName":"lib/forge-std/src/Script.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Base.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Script":{"0.8.23+commit.f704f362.Linux.gcc":"Script.sol/Script.json"}}},"lib/forge-std/src/StdAssertions.sol":{"lastModificationDate":1714580983859,"contentHash":"6cc2858240bcd443debbbf075490e325","sourceName":"lib/forge-std/src/StdAssertions.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/StdMath.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdAssertions":{"0.8.23+commit.f704f362.Linux.gcc":"StdAssertions.sol/StdAssertions.json"}}},"lib/forge-std/src/StdChains.sol":{"lastModificationDate":1714580983859,"contentHash":"b0324b2e5a11948f852032aa293b3a05","sourceName":"lib/forge-std/src/StdChains.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdChains":{"0.8.23+commit.f704f362.Linux.gcc":"StdChains.sol/StdChains.json"}}},"lib/forge-std/src/StdCheats.sol":{"lastModificationDate":1714580983859,"contentHash":"d984e2c76dae07bac1e292af2a5d4fd1","sourceName":"lib/forge-std/src/StdCheats.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/StdStorage.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console2.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdCheats":{"0.8.23+commit.f704f362.Linux.gcc":"StdCheats.sol/StdCheats.json"},"StdCheatsSafe":{"0.8.23+commit.f704f362.Linux.gcc":"StdCheats.sol/StdCheatsSafe.json"}}},"lib/forge-std/src/StdError.sol":{"lastModificationDate":1714580983859,"contentHash":"64c896e1276a291776e5ea5aecb3870a","sourceName":"lib/forge-std/src/StdError.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdError":{"0.8.23+commit.f704f362.Linux.gcc":"StdError.sol/stdError.json"}}},"lib/forge-std/src/StdInvariant.sol":{"lastModificationDate":1714580983859,"contentHash":"0a580d6fac69e9d4b6504f747f3c0c24","sourceName":"lib/forge-std/src/StdInvariant.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdInvariant":{"0.8.23+commit.f704f362.Linux.gcc":"StdInvariant.sol/StdInvariant.json"}}},"lib/forge-std/src/StdJson.sol":{"lastModificationDate":1714580983859,"contentHash":"b5de4d3e9eda3333019b0e407ec2a1ac","sourceName":"lib/forge-std/src/StdJson.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.0, <0.9.0","artifacts":{"stdJson":{"0.8.23+commit.f704f362.Linux.gcc":"StdJson.sol/stdJson.json"}}},"lib/forge-std/src/StdMath.sol":{"lastModificationDate":1714580983859,"contentHash":"9da8f453eba6bb98f3d75bc6822bfb29","sourceName":"lib/forge-std/src/StdMath.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdMath":{"0.8.23+commit.f704f362.Linux.gcc":"StdMath.sol/stdMath.json"}}},"lib/forge-std/src/StdStorage.sol":{"lastModificationDate":1714580983859,"contentHash":"abd6f3379e6e2a7979b18abc21aea0c1","sourceName":"lib/forge-std/src/StdStorage.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdStorage":{"0.8.23+commit.f704f362.Linux.gcc":"StdStorage.sol/stdStorage.json"},"stdStorageSafe":{"0.8.23+commit.f704f362.Linux.gcc":"StdStorage.sol/stdStorageSafe.json"}}},"lib/forge-std/src/StdStyle.sol":{"lastModificationDate":1714580983859,"contentHash":"6281165a12aa639705c691fccefd855e","sourceName":"lib/forge-std/src/StdStyle.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"StdStyle":{"0.8.23+commit.f704f362.Linux.gcc":"StdStyle.sol/StdStyle.json"}}},"lib/forge-std/src/StdUtils.sol":{"lastModificationDate":1714580983859,"contentHash":"3ce83748fd76644688f916c9cced545b","sourceName":"lib/forge-std/src/StdUtils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/interfaces/IMulticall3.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdUtils":{"0.8.23+commit.f704f362.Linux.gcc":"StdUtils.sol/StdUtils.json"}}},"lib/forge-std/src/Test.sol":{"lastModificationDate":1714580983859,"contentHash":"15866901137b5670eabf31362523bd28","sourceName":"lib/forge-std/src/Test.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Test":{"0.8.23+commit.f704f362.Linux.gcc":"Test.sol/Test.json"}}},"lib/forge-std/src/Vm.sol":{"lastModificationDate":1714580983859,"contentHash":"99c76f92020cc3d67eca52e07eea5d77","sourceName":"lib/forge-std/src/Vm.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Vm":{"0.8.23+commit.f704f362.Linux.gcc":"Vm.sol/Vm.json"},"VmSafe":{"0.8.23+commit.f704f362.Linux.gcc":"Vm.sol/VmSafe.json"}}},"lib/forge-std/src/console.sol":{"lastModificationDate":1714580983859,"contentHash":"100b8a33b917da1147740d7ab8b0ded3","sourceName":"lib/forge-std/src/console.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"console":{"0.8.23+commit.f704f362.Linux.gcc":"console.sol/console.json"}}},"lib/forge-std/src/console2.sol":{"lastModificationDate":1714580983859,"contentHash":"491ca717c1915995e78cc361485a3067","sourceName":"lib/forge-std/src/console2.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"console2":{"0.8.23+commit.f704f362.Linux.gcc":"console2.sol/console2.json"}}},"lib/forge-std/src/interfaces/IMulticall3.sol":{"lastModificationDate":1714580983859,"contentHash":"7b131ca1ca32ef6378b7b9ad5488b901","sourceName":"lib/forge-std/src/interfaces/IMulticall3.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"IMulticall3":{"0.8.23+commit.f704f362.Linux.gcc":"IMulticall3.sol/IMulticall3.json"}}},"lib/forge-std/src/safeconsole.sol":{"lastModificationDate":1714580983859,"contentHash":"ac3b1bf5a444db5db3656021830258a8","sourceName":"lib/forge-std/src/safeconsole.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"safeconsole":{"0.8.23+commit.f704f362.Linux.gcc":"safeconsole.sol/safeconsole.json"}}},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"lastModificationDate":1714580994579,"contentHash":"f0cedd674b4863ee90d1521a92ab82df","sourceName":"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Initializable":{"0.8.23+commit.f704f362.Linux.gcc":"Initializable.sol/Initializable.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"lastModificationDate":1714581164439,"contentHash":"d3c790edc9ccf808a17c5a6cd13614fd","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol"],"versionRequirement":"^0.8.20","artifacts":{"Ownable":{"0.8.23+commit.f704f362.Linux.gcc":"Ownable.sol/Ownable.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol":{"lastModificationDate":1714581164439,"contentHash":"4e17c826a54a8ee1a185449d4695d07d","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"IERC1967":{"0.8.23+commit.f704f362.Linux.gcc":"IERC1967.sol/IERC1967.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol":{"lastModificationDate":1714581164449,"contentHash":"fba0de767173425a75670beddccf01fe","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ERC1967Proxy":{"0.8.23+commit.f704f362.Linux.gcc":"ERC1967Proxy.sol/ERC1967Proxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"lastModificationDate":1714581164449,"contentHash":"78331b52daf168288b44d1988ba97a93","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ERC1967Utils":{"0.8.23+commit.f704f362.Linux.gcc":"ERC1967Utils.sol/ERC1967Utils.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol":{"lastModificationDate":1714581164449,"contentHash":"35308c2fa7be99a959494c37e8257c16","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Proxy":{"0.8.23+commit.f704f362.Linux.gcc":"Proxy.sol/Proxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol":{"lastModificationDate":1714581164449,"contentHash":"2cfbef821f8d2e417c7cc5d632d7c843","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"BeaconProxy":{"0.8.23+commit.f704f362.Linux.gcc":"BeaconProxy.sol/BeaconProxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"lastModificationDate":1714581164449,"contentHash":"0a5c323fd908535580597848b8e550fb","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"IBeacon":{"0.8.23+commit.f704f362.Linux.gcc":"IBeacon.sol/IBeacon.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol":{"lastModificationDate":1714581164449,"contentHash":"199aceb57a6d0b08264d822f36b20494","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol"],"versionRequirement":"^0.8.20","artifacts":{"UpgradeableBeacon":{"0.8.23+commit.f704f362.Linux.gcc":"UpgradeableBeacon.sol/UpgradeableBeacon.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol":{"lastModificationDate":1714581164449,"contentHash":"bbd45bfcd6202c35718661cc5d051226","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ProxyAdmin":{"0.8.23+commit.f704f362.Linux.gcc":"ProxyAdmin.sol/ProxyAdmin.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol":{"lastModificationDate":1714581164449,"contentHash":"9f20fe1fb2429a20ea3fb5ce46f19303","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ITransparentUpgradeableProxy":{"0.8.23+commit.f704f362.Linux.gcc":"TransparentUpgradeableProxy.sol/ITransparentUpgradeableProxy.json"},"TransparentUpgradeableProxy":{"0.8.23+commit.f704f362.Linux.gcc":"TransparentUpgradeableProxy.sol/TransparentUpgradeableProxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"lastModificationDate":1714581164459,"contentHash":"79c699f80eb8a9b168cb34e37816f894","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Address":{"0.8.23+commit.f704f362.Linux.gcc":"Address.sol/Address.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol":{"lastModificationDate":1714581164459,"contentHash":"01c847e2af51f468cb66d9ed83bc3cec","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Context":{"0.8.23+commit.f704f362.Linux.gcc":"Context.sol/Context.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"lastModificationDate":1714581164459,"contentHash":"7762519b985a5a4153f32ca1e2089dee","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"StorageSlot":{"0.8.23+commit.f704f362.Linux.gcc":"StorageSlot.sol/StorageSlot.json"}}},"lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol":{"lastModificationDate":1714581177899,"contentHash":"2b4e9d2225a4542b48016c76b16268a2","sourceName":"lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"strings":{"0.8.23+commit.f704f362.Linux.gcc":"solidity-stringutils/strings.sol/strings.json"}}},"lib/openzeppelin-foundry-upgrades/src/Upgrades.sol":{"lastModificationDate":1714581171259,"contentHash":"66d14f97719ac594ab4980ed62a4bff8","sourceName":"lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol"],"versionRequirement":"^0.8.20","artifacts":{"Upgrades":{"0.8.23+commit.f704f362.Linux.gcc":"Upgrades.sol/Upgrades.json"}}},"lib/openzeppelin-foundry-upgrades/src/Versions.sol":{"lastModificationDate":1714581171259,"contentHash":"aa7aef396d85d0e253b49d3c467dc468","sourceName":"lib/openzeppelin-foundry-upgrades/src/Versions.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Versions":{"0.8.23+commit.f704f362.Linux.gcc":"Versions.sol/Versions.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol":{"lastModificationDate":1714581180009,"contentHash":"86ef0154470f2f264e61fce225276ff9","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol"],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroEndpoint":{"0.8.23+commit.f704f362.Linux.gcc":"ILayerZeroEndpoint.sol/ILayerZeroEndpoint.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol":{"lastModificationDate":1714581180009,"contentHash":"ed9a0d4dbd5e18a6ced83725df0db4f3","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroReceiver":{"0.8.23+commit.f704f362.Linux.gcc":"ILayerZeroReceiver.sol/ILayerZeroReceiver.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol":{"lastModificationDate":1714581180009,"contentHash":"1e1af18cedcca5a5e82e96cdbe314d95","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroUserApplicationConfig":{"0.8.23+commit.f704f362.Linux.gcc":"ILayerZeroUserApplicationConfig.sol/ILayerZeroUserApplicationConfig.json"}}},"lib/solidity-examples/contracts/lzApp/libs/LzLib.sol":{"lastModificationDate":1714581180009,"contentHash":"d9f2cc63e84dd0cd244a5adbbfcda44d","sourceName":"lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.6.0","artifacts":{"LzLib":{"0.8.23+commit.f704f362.Linux.gcc":"LzLib.sol/LzLib.json"}}},"lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol":{"lastModificationDate":1714581180009,"contentHash":"c01d06f3b912ce04398bd127bb069c0c","sourceName":"lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol"],"versionRequirement":"^0.8.0","artifacts":{"LZEndpointMock":{"0.8.23+commit.f704f362.Linux.gcc":"LZEndpointMock.sol/LZEndpointMock.json"}}},"lib/wormhole-solidity-sdk/src/Utils.sol":{"lastModificationDate":1714581180039,"contentHash":"8366c6827b67e28622f2d0c5ef530a95","sourceName":"lib/wormhole-solidity-sdk/src/Utils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol"],"versionRequirement":"^0.8.13","artifacts":{}},"lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol":{"lastModificationDate":1714581180039,"contentHash":"d3f395dc838796643e7a71419900ab23","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IERC20":{"0.8.23+commit.f704f362.Linux.gcc":"IERC20.sol/IERC20.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol":{"lastModificationDate":1714581180039,"contentHash":"effdc02941abf3d3e90d2e4c3e5fa6b5","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol"],"versionRequirement":"^0.8.0","artifacts":{"ITokenBridge":{"0.8.23+commit.f704f362.Linux.gcc":"ITokenBridge.sol/ITokenBridge.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol":{"lastModificationDate":1714581180039,"contentHash":"90020aa00c69797588ffd23484bab40b","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol"],"versionRequirement":"^0.8.0","artifacts":{"IWETH":{"0.8.23+commit.f704f362.Linux.gcc":"IWETH.sol/IWETH.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol":{"lastModificationDate":1714581180039,"contentHash":"17bcb8ab1190b494435234940d3f7ba3","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormhole":{"0.8.23+commit.f704f362.Linux.gcc":"IWormhole.sol/IWormhole.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol":{"lastModificationDate":1714581180039,"contentHash":"45470d92c4bc6d2fea60e2a719d6fad5","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormholeReceiver":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeReceiver.sol/IWormholeReceiver.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol":{"lastModificationDate":1714581180039,"contentHash":"f0c31126b4d7df3b1f7de5933a2d8755","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormholeRelayer":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeRelayer.sol/IWormholeRelayer.json"},"IWormholeRelayerBase":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeRelayer.sol/IWormholeRelayerBase.json"},"IWormholeRelayerDelivery":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeRelayer.sol/IWormholeRelayerDelivery.json"},"IWormholeRelayerSend":{"0.8.23+commit.f704f362.Linux.gcc":"IWormholeRelayer.sol/IWormholeRelayerSend.json"}}},"lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol":{"lastModificationDate":1714581180039,"contentHash":"5dc3cd1df4ef5a5c06bfa77d5b0fb616","sourceName":"lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol"],"versionRequirement":"^0.8.13","artifacts":{"ERC20":{"0.8.23+commit.f704f362.Linux.gcc":"ERC20Mock.sol/ERC20.json"},"ERC20Mock":{"0.8.23+commit.f704f362.Linux.gcc":"ERC20Mock.sol/ERC20Mock.json"}}},"lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol":{"lastModificationDate":1714581180039,"contentHash":"3bad89b755087e6ae4db134e852cc048","sourceName":"lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeRelayerBasicTest":{"0.8.23+commit.f704f362.Linux.gcc":"WormholeRelayerTest.sol/WormholeRelayerBasicTest.json"},"WormholeRelayerTest":{"0.8.23+commit.f704f362.Linux.gcc":"WormholeRelayerTest.sol/WormholeRelayerTest.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol":{"lastModificationDate":1714581180039,"contentHash":"51df31343142a8bb61160161ee03a040","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0, <0.9.0","artifacts":{"BytesLib":{"0.8.23+commit.f704f362.Linux.gcc":"BytesLib.sol/BytesLib.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol":{"lastModificationDate":1714581180039,"contentHash":"84ab4b6332ff0bca993506b10843da47","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":"^0.8.13","artifacts":{"BytesParsing":{"0.8.23+commit.f704f362.Linux.gcc":"BytesParsing.sol/BytesParsing.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol":{"lastModificationDate":1714581180039,"contentHash":"7a3aa31b38d0bd707385cf4a109e2485","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol"],"versionRequirement":"^0.8.13","artifacts":{}},"lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol":{"lastModificationDate":1714581180039,"contentHash":"c44b3c368d72d80f2f87ff26702d7c25","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol"],"versionRequirement":"^0.8.13","artifacts":{}},"lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol":{"lastModificationDate":1714581180039,"contentHash":"4ffa8667101e55084275186cf211e143","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol"],"versionRequirement":"^0.8.0","artifacts":{"MockOffchainRelayer":{"0.8.23+commit.f704f362.Linux.gcc":"MockOffchainRelayer.sol/MockOffchainRelayer.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol":{"lastModificationDate":1714581180039,"contentHash":"bfcd29cb521141921f12a53bbd2be30e","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeSimulator":{"0.8.23+commit.f704f362.Linux.gcc":"WormholeSimulator.sol/WormholeSimulator.json"}}},"library/utils/RLPDecodeStruct.sol":{"lastModificationDate":1714578796620,"contentHash":"d61a47c63bff5f73fe65d0a2aaee71bc","sourceName":"library/utils/RLPDecodeStruct.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"RLPDecodeStruct":{"0.8.23+commit.f704f362.Linux.gcc":"RLPDecodeStruct.sol/RLPDecodeStruct.json"}}},"library/utils/RLPEncodeStruct.sol":{"lastModificationDate":1714578796620,"contentHash":"4c80671dfcde6a86023ff997f9da5dd9","sourceName":"library/utils/RLPEncodeStruct.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"RLPEncodeStruct":{"0.8.23+commit.f704f362.Linux.gcc":"RLPEncodeStruct.sol/RLPEncodeStruct.json"}}},"library/utils/Types.sol":{"lastModificationDate":1714578796620,"contentHash":"749a5c0849e27051663dedf475d4840a","sourceName":"library/utils/Types.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"Types":{"0.8.23+commit.f704f362.Linux.gcc":"Types.sol/Types.json"}}},"library/xcall/interfaces/IBSH.sol":{"lastModificationDate":1714578796620,"contentHash":"8fd4c949cdbf37dad2e7223d27b4d823","sourceName":"library/xcall/interfaces/IBSH.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IBSH":{"0.8.23+commit.f704f362.Linux.gcc":"IBSH.sol/IBSH.json"}}},"library/xcall/interfaces/ICallService.sol":{"lastModificationDate":1714578796620,"contentHash":"38a85024031afc083704b91cbb69d0df","sourceName":"library/xcall/interfaces/ICallService.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallService":{"0.8.23+commit.f704f362.Linux.gcc":"ICallService.sol/ICallService.json"}}},"library/xcall/interfaces/ICallServiceReceiver.sol":{"lastModificationDate":1714578796620,"contentHash":"2ca794c9547a409bda43e8cd9cddc21d","sourceName":"library/xcall/interfaces/ICallServiceReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallServiceReceiver":{"0.8.23+commit.f704f362.Linux.gcc":"ICallServiceReceiver.sol/ICallServiceReceiver.json"}}},"library/xcall/interfaces/ICallServiceV1.sol":{"lastModificationDate":1714578796620,"contentHash":"cbf6ad5b4b87689ab5cc6d0838150069","sourceName":"library/xcall/interfaces/ICallServiceV1.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallServiceV1":{"0.8.23+commit.f704f362.Linux.gcc":"ICallServiceV1.sol/ICallServiceV1.json"}}},"library/xcall/interfaces/IDefaultCallServiceReceiver.sol":{"lastModificationDate":1714578796620,"contentHash":"9ed4a1596fa1e5e72f7109dbab545534","sourceName":"library/xcall/interfaces/IDefaultCallServiceReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IDefaultCallServiceReceiver":{"0.8.23+commit.f704f362.Linux.gcc":"IDefaultCallServiceReceiver.sol/IDefaultCallServiceReceiver.json"}}},"library/xcall/utils/Integers.sol":{"lastModificationDate":1714578796620,"contentHash":"e3d539bdfbc1bc771779239375c3885b","sourceName":"library/xcall/utils/Integers.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"Integers":{"0.8.23+commit.f704f362.Linux.gcc":"Integers.sol/Integers.json"}}},"library/xcall/utils/NetworkAddress.sol":{"lastModificationDate":1714578796620,"contentHash":"f834f12fc2e8e35a1cbfcda41d1e51d2","sourceName":"library/xcall/utils/NetworkAddress.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"NetworkAddress":{"0.8.23+commit.f704f362.Linux.gcc":"NetworkAddress.sol/NetworkAddress.json"}}},"library/xcall/utils/ParseAddress.sol":{"lastModificationDate":1714578796620,"contentHash":"717833bbbc0f961eda0f1b00dd1dec8c","sourceName":"library/xcall/utils/ParseAddress.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ParseAddress":{"0.8.23+commit.f704f362.Linux.gcc":"ParseAddress.sol/ParseAddress.json"}}},"library/xcall/utils/RLPDecode.sol":{"lastModificationDate":1714578796620,"contentHash":"8a237d675ba6b1b4a7ff47dfcb229869","sourceName":"library/xcall/utils/RLPDecode.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"RLPDecode":{"0.8.23+commit.f704f362.Linux.gcc":"RLPDecode.sol/RLPDecode.json"}}},"library/xcall/utils/RLPEncode.sol":{"lastModificationDate":1714578796620,"contentHash":"3d288700d76882ab990800af30932805","sourceName":"library/xcall/utils/RLPEncode.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"RLPEncode":{"0.8.23+commit.f704f362.Linux.gcc":"RLPEncode.sol/RLPEncode.json"}}},"library/xcall/utils/Strings.sol":{"lastModificationDate":1714578796620,"contentHash":"15688932876357610555acf8dafa69d9","sourceName":"library/xcall/utils/Strings.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"Strings":{"0.8.23+commit.f704f362.Linux.gcc":"Strings.sol/Strings.json"}}},"script/CallService.s.sol":{"lastModificationDate":1714578796620,"contentHash":"f21b7f9f99e65c98e05af8da9b980213","sourceName":"script/CallService.s.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/Script.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.18","artifacts":{"DeployCallService":{"0.8.23+commit.f704f362.Linux.gcc":"CallService.s.sol/DeployCallService.json"}}},"script/XCallOperation.s.sol":{"lastModificationDate":1714578796620,"contentHash":"1258986ef23db12d4ad845b8398f0f3f","sourceName":"script/XCallOperation.s.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/Script.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.18","artifacts":{"WormholeTest":{"0.8.23+commit.f704f362.Linux.gcc":"XCallOperation.s.sol/WormholeTest.json"}}},"test/adapters/CentralizedConnection.t.sol":{"lastModificationDate":1714578796620,"contentHash":"76e7d47b357b6bffb8d1dec5aebf6717","sourceName":"test/adapters/CentralizedConnection.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CentralizedConnectionTest":{"0.8.23+commit.f704f362.Linux.gcc":"CentralizedConnection.t.sol/CentralizedConnectionTest.json"}}},"test/adapters/LayerZeroAdapter.t.sol":{"lastModificationDate":1714578796620,"contentHash":"e01e83e6e99adf9eadc8e19dd1c12d07","sourceName":"test/adapters/LayerZeroAdapter.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"LayerZeroAdapterTest":{"0.8.23+commit.f704f362.Linux.gcc":"LayerZeroAdapter.t.sol/LayerZeroAdapterTest.json"}}},"test/adapters/WormholeAdapter.t.sol":{"lastModificationDate":1714578796620,"contentHash":"224f8073bc96bb1948fb15441a1c9050","sourceName":"test/adapters/WormholeAdapter.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeAdapterTest":{"0.8.23+commit.f704f362.Linux.gcc":"WormholeAdapter.t.sol/WormholeAdapterTest.json"}}},"test/xcall/CallService.t.sol":{"lastModificationDate":1714578796620,"contentHash":"8514d97f4e5eddea90053217cbef46fe","sourceName":"test/xcall/CallService.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/mocks/dapp/DAppProxySample.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CallServiceTest":{"0.8.23+commit.f704f362.Linux.gcc":"CallService.t.sol/CallServiceTest.json"},"ResponseContract":{"0.8.23+commit.f704f362.Linux.gcc":"CallService.t.sol/ResponseContract.json"}}},"test/xcall/CallServiceV1.t.sol":{"lastModificationDate":1714578796620,"contentHash":"616f1567f33618bf0ead10bbc4e08745","sourceName":"test/xcall/CallServiceV1.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","viaIR":false,"libraries":{}}},"imports":["contracts/mocks/dapp/DAppProxySample.sol","contracts/xcall/CallServiceV1.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/ICallServiceV1.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CallServiceV1Test":{"0.8.23+commit.f704f362.Linux.gcc":"CallServiceV1.t.sol/CallServiceV1Test.json"}}}}} +{"_format":"ethers-rs-sol-cache-3","paths":{"artifacts":"out","build_infos":"out/build-info","sources":"contracts","tests":"test","scripts":"script","libraries":["lib"]},"files":{"contracts/adapters/CentralizedConnection.sol":{"lastModificationDate":1714379207191,"contentHash":"5d955f6e51b9a2148459f809272443ae","sourceName":"contracts/adapters/CentralizedConnection.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"CentralizedConnection":{"0.8.23+commit.f704f362.Darwin.appleclang":"CentralizedConnection.sol/CentralizedConnection.json"}}},"contracts/adapters/ClusterConnection.sol":{"lastModificationDate":1728291046525,"contentHash":"975419644bf86a9f44fd45c9b352fabf","sourceName":"contracts/adapters/ClusterConnection.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"ClusterConnection":{"0.8.23+commit.f704f362.Darwin.appleclang":"ClusterConnection.sol/ClusterConnection.json"}}},"contracts/adapters/LayerZeroAdapter.sol":{"lastModificationDate":1714379207191,"contentHash":"d094a841c17d3f15f779e8278d491b43","sourceName":"contracts/adapters/LayerZeroAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"LayerZeroAdapter":{"0.8.23+commit.f704f362.Darwin.appleclang":"LayerZeroAdapter.sol/LayerZeroAdapter.json"}}},"contracts/adapters/WormholeAdapter.sol":{"lastModificationDate":1714379207192,"contentHash":"b83f9cae20556e583a62067d3ee83ef2","sourceName":"contracts/adapters/WormholeAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/xcall/interfaces/IConnection.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"WormholeAdapter":{"0.8.23+commit.f704f362.Darwin.appleclang":"WormholeAdapter.sol/WormholeAdapter.json"}}},"contracts/adapters/interfaces/ILayerZeroAdapter.sol":{"lastModificationDate":1701785307135,"contentHash":"f50709b9cbce46fbef763fb493f1241a","sourceName":"contracts/adapters/interfaces/ILayerZeroAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ILayerZeroAdapter":{"0.8.23+commit.f704f362.Darwin.appleclang":"ILayerZeroAdapter.sol/ILayerZeroAdapter.json"}}},"contracts/adapters/interfaces/IWormholeAdapter.sol":{"lastModificationDate":1701785307135,"contentHash":"a712c7736208ffbf1a7b6b3daac0ae02","sourceName":"contracts/adapters/interfaces/IWormholeAdapter.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IWormholeAdapter":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeAdapter.sol/IWormholeAdapter.json"}}},"contracts/mocks/dapp/DAppProxySample.sol":{"lastModificationDate":1714379207192,"contentHash":"24e6a3a7cf297bd769df8649a6bd5540","sourceName":"contracts/mocks/dapp/DAppProxySample.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol"],"versionRequirement":">=0.8.0","artifacts":{"DAppProxySample":{"0.8.23+commit.f704f362.Darwin.appleclang":"DAppProxySample.sol/DAppProxySample.json"}}},"contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol":{"lastModificationDate":1714379207192,"contentHash":"70f440bba0a2f34f25b7b1afb19d670f","sourceName":"contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"MultiProtocolSampleDapp":{"0.8.23+commit.f704f362.Darwin.appleclang":"MultiProtocolSampleDapp.sol/MultiProtocolSampleDapp.json"}}},"contracts/xcall/CallService.sol":{"lastModificationDate":1728281146372,"contentHash":"0a6604abf67b604634f29518344926bf","sourceName":"contracts/xcall/CallService.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.0","artifacts":{"CallService":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallService.sol/CallService.json"}}},"contracts/xcall/CallServiceV1.sol":{"lastModificationDate":1714379207192,"contentHash":"1ade36fba8cd84927086fa52d2f988ec","sourceName":"contracts/xcall/CallServiceV1.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/ICallServiceV1.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.0","artifacts":{"CallServiceV1":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallServiceV1.sol/CallServiceV1.json"}}},"contracts/xcall/interfaces/IConnection.sol":{"lastModificationDate":1701785307135,"contentHash":"c0ee93405e30cbc20c985981aec534b7","sourceName":"contracts/xcall/interfaces/IConnection.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IConnection":{"0.8.23+commit.f704f362.Darwin.appleclang":"IConnection.sol/IConnection.json"}}},"contracts/xcall/interfaces/IFeeManage.sol":{"lastModificationDate":1701785307135,"contentHash":"98dba095babc43947dce1d0b28cd8c55","sourceName":"contracts/xcall/interfaces/IFeeManage.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IFeeManage":{"0.8.23+commit.f704f362.Darwin.appleclang":"IFeeManage.sol/IFeeManage.json"}}},"lib/forge-std/lib/ds-test/src/test.sol":{"lastModificationDate":1701786714449,"contentHash":"9febff9d09f18af5306669dc276c4c43","sourceName":"lib/forge-std/lib/ds-test/src/test.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"DSTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"test.sol/DSTest.json"}}},"lib/forge-std/src/Base.sol":{"lastModificationDate":1701786709810,"contentHash":"ee13c050b1914464f1d3f90cde90204b","sourceName":"lib/forge-std/src/Base.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/StdStorage.sol","lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"CommonBase":{"0.8.23+commit.f704f362.Darwin.appleclang":"Base.sol/CommonBase.json"},"ScriptBase":{"0.8.23+commit.f704f362.Darwin.appleclang":"Base.sol/ScriptBase.json"},"TestBase":{"0.8.23+commit.f704f362.Darwin.appleclang":"Base.sol/TestBase.json"}}},"lib/forge-std/src/Script.sol":{"lastModificationDate":1701786709810,"contentHash":"ba325c778a7da8a21c2136aa32763c14","sourceName":"lib/forge-std/src/Script.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Base.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Script":{"0.8.23+commit.f704f362.Darwin.appleclang":"Script.sol/Script.json"}}},"lib/forge-std/src/StdAssertions.sol":{"lastModificationDate":1701786709810,"contentHash":"6cc2858240bcd443debbbf075490e325","sourceName":"lib/forge-std/src/StdAssertions.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/StdMath.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdAssertions":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdAssertions.sol/StdAssertions.json"}}},"lib/forge-std/src/StdChains.sol":{"lastModificationDate":1709554676481,"contentHash":"b0324b2e5a11948f852032aa293b3a05","sourceName":"lib/forge-std/src/StdChains.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdChains":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdChains.sol/StdChains.json"}}},"lib/forge-std/src/StdCheats.sol":{"lastModificationDate":1709554676482,"contentHash":"d984e2c76dae07bac1e292af2a5d4fd1","sourceName":"lib/forge-std/src/StdCheats.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/StdStorage.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console2.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdCheats":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdCheats.sol/StdCheats.json"},"StdCheatsSafe":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdCheats.sol/StdCheatsSafe.json"}}},"lib/forge-std/src/StdError.sol":{"lastModificationDate":1701786709811,"contentHash":"64c896e1276a291776e5ea5aecb3870a","sourceName":"lib/forge-std/src/StdError.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdError":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdError.sol/stdError.json"}}},"lib/forge-std/src/StdInvariant.sol":{"lastModificationDate":1701786709811,"contentHash":"0a580d6fac69e9d4b6504f747f3c0c24","sourceName":"lib/forge-std/src/StdInvariant.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdInvariant":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdInvariant.sol/StdInvariant.json"}}},"lib/forge-std/src/StdJson.sol":{"lastModificationDate":1709554676482,"contentHash":"b5de4d3e9eda3333019b0e407ec2a1ac","sourceName":"lib/forge-std/src/StdJson.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.0, <0.9.0","artifacts":{"stdJson":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdJson.sol/stdJson.json"}}},"lib/forge-std/src/StdMath.sol":{"lastModificationDate":1701786709811,"contentHash":"9da8f453eba6bb98f3d75bc6822bfb29","sourceName":"lib/forge-std/src/StdMath.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdMath":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdMath.sol/stdMath.json"}}},"lib/forge-std/src/StdStorage.sol":{"lastModificationDate":1701786709811,"contentHash":"abd6f3379e6e2a7979b18abc21aea0c1","sourceName":"lib/forge-std/src/StdStorage.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"stdStorage":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdStorage.sol/stdStorage.json"},"stdStorageSafe":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdStorage.sol/stdStorageSafe.json"}}},"lib/forge-std/src/StdStyle.sol":{"lastModificationDate":1701786709811,"contentHash":"6281165a12aa639705c691fccefd855e","sourceName":"lib/forge-std/src/StdStyle.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol"],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"StdStyle":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdStyle.sol/StdStyle.json"}}},"lib/forge-std/src/StdUtils.sol":{"lastModificationDate":1709554676482,"contentHash":"3ce83748fd76644688f916c9cced545b","sourceName":"lib/forge-std/src/StdUtils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/interfaces/IMulticall3.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"StdUtils":{"0.8.23+commit.f704f362.Darwin.appleclang":"StdUtils.sol/StdUtils.json"}}},"lib/forge-std/src/Test.sol":{"lastModificationDate":1701786709811,"contentHash":"15866901137b5670eabf31362523bd28","sourceName":"lib/forge-std/src/Test.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol"],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Test":{"0.8.23+commit.f704f362.Darwin.appleclang":"Test.sol/Test.json"}}},"lib/forge-std/src/Vm.sol":{"lastModificationDate":1709554676483,"contentHash":"99c76f92020cc3d67eca52e07eea5d77","sourceName":"lib/forge-std/src/Vm.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"Vm":{"0.8.23+commit.f704f362.Darwin.appleclang":"Vm.sol/Vm.json"},"VmSafe":{"0.8.23+commit.f704f362.Darwin.appleclang":"Vm.sol/VmSafe.json"}}},"lib/forge-std/src/console.sol":{"lastModificationDate":1701786709812,"contentHash":"100b8a33b917da1147740d7ab8b0ded3","sourceName":"lib/forge-std/src/console.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"console":{"0.8.23+commit.f704f362.Darwin.appleclang":"console.sol/console.json"}}},"lib/forge-std/src/console2.sol":{"lastModificationDate":1701786709812,"contentHash":"491ca717c1915995e78cc361485a3067","sourceName":"lib/forge-std/src/console2.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.4.22, <0.9.0","artifacts":{"console2":{"0.8.23+commit.f704f362.Darwin.appleclang":"console2.sol/console2.json"}}},"lib/forge-std/src/interfaces/IMulticall3.sol":{"lastModificationDate":1701786709813,"contentHash":"7b131ca1ca32ef6378b7b9ad5488b901","sourceName":"lib/forge-std/src/interfaces/IMulticall3.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"IMulticall3":{"0.8.23+commit.f704f362.Darwin.appleclang":"IMulticall3.sol/IMulticall3.json"}}},"lib/forge-std/src/safeconsole.sol":{"lastModificationDate":1701786709813,"contentHash":"ac3b1bf5a444db5db3656021830258a8","sourceName":"lib/forge-std/src/safeconsole.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.2, <0.9.0","artifacts":{"safeconsole":{"0.8.23+commit.f704f362.Darwin.appleclang":"safeconsole.sol/safeconsole.json"}}},"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol":{"lastModificationDate":1703565527523,"contentHash":"f0cedd674b4863ee90d1521a92ab82df","sourceName":"lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Initializable":{"0.8.23+commit.f704f362.Darwin.appleclang":"Initializable.sol/Initializable.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"lastModificationDate":1703644650423,"contentHash":"d3c790edc9ccf808a17c5a6cd13614fd","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol"],"versionRequirement":"^0.8.20","artifacts":{"Ownable":{"0.8.23+commit.f704f362.Darwin.appleclang":"Ownable.sol/Ownable.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol":{"lastModificationDate":1703644650427,"contentHash":"4e17c826a54a8ee1a185449d4695d07d","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"IERC1967":{"0.8.23+commit.f704f362.Darwin.appleclang":"IERC1967.sol/IERC1967.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol":{"lastModificationDate":1703644650437,"contentHash":"fba0de767173425a75670beddccf01fe","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ERC1967Proxy":{"0.8.23+commit.f704f362.Darwin.appleclang":"ERC1967Proxy.sol/ERC1967Proxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol":{"lastModificationDate":1703644650437,"contentHash":"78331b52daf168288b44d1988ba97a93","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ERC1967Utils":{"0.8.23+commit.f704f362.Darwin.appleclang":"ERC1967Utils.sol/ERC1967Utils.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol":{"lastModificationDate":1703644650437,"contentHash":"35308c2fa7be99a959494c37e8257c16","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Proxy":{"0.8.23+commit.f704f362.Darwin.appleclang":"Proxy.sol/Proxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol":{"lastModificationDate":1703644650437,"contentHash":"2cfbef821f8d2e417c7cc5d632d7c843","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"BeaconProxy":{"0.8.23+commit.f704f362.Darwin.appleclang":"BeaconProxy.sol/BeaconProxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol":{"lastModificationDate":1703644650437,"contentHash":"0a5c323fd908535580597848b8e550fb","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"IBeacon":{"0.8.23+commit.f704f362.Darwin.appleclang":"IBeacon.sol/IBeacon.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol":{"lastModificationDate":1703644650437,"contentHash":"199aceb57a6d0b08264d822f36b20494","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol"],"versionRequirement":"^0.8.20","artifacts":{"UpgradeableBeacon":{"0.8.23+commit.f704f362.Darwin.appleclang":"UpgradeableBeacon.sol/UpgradeableBeacon.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol":{"lastModificationDate":1703644650437,"contentHash":"bbd45bfcd6202c35718661cc5d051226","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ProxyAdmin":{"0.8.23+commit.f704f362.Darwin.appleclang":"ProxyAdmin.sol/ProxyAdmin.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol":{"lastModificationDate":1703644650438,"contentHash":"9f20fe1fb2429a20ea3fb5ce46f19303","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ITransparentUpgradeableProxy":{"0.8.23+commit.f704f362.Darwin.appleclang":"TransparentUpgradeableProxy.sol/ITransparentUpgradeableProxy.json"},"TransparentUpgradeableProxy":{"0.8.23+commit.f704f362.Darwin.appleclang":"TransparentUpgradeableProxy.sol/TransparentUpgradeableProxy.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol":{"lastModificationDate":1703644650442,"contentHash":"79c699f80eb8a9b168cb34e37816f894","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Address":{"0.8.23+commit.f704f362.Darwin.appleclang":"Address.sol/Address.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol":{"lastModificationDate":1703644650443,"contentHash":"01c847e2af51f468cb66d9ed83bc3cec","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Context":{"0.8.23+commit.f704f362.Darwin.appleclang":"Context.sol/Context.json"}}},"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"lastModificationDate":1703644650444,"contentHash":"7762519b985a5a4153f32ca1e2089dee","sourceName":"lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"StorageSlot":{"0.8.23+commit.f704f362.Darwin.appleclang":"StorageSlot.sol/StorageSlot.json"}}},"lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol":{"lastModificationDate":1703644701339,"contentHash":"2b4e9d2225a4542b48016c76b16268a2","sourceName":"lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"strings":{"0.8.23+commit.f704f362.Darwin.appleclang":"solidity-stringutils/strings.sol/strings.json"}}},"lib/openzeppelin-foundry-upgrades/src/Upgrades.sol":{"lastModificationDate":1703644664575,"contentHash":"66d14f97719ac594ab4980ed62a4bff8","sourceName":"lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol"],"versionRequirement":"^0.8.20","artifacts":{"Upgrades":{"0.8.23+commit.f704f362.Darwin.appleclang":"Upgrades.sol/Upgrades.json"}}},"lib/openzeppelin-foundry-upgrades/src/Versions.sol":{"lastModificationDate":1703644664575,"contentHash":"aa7aef396d85d0e253b49d3c467dc468","sourceName":"lib/openzeppelin-foundry-upgrades/src/Versions.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.20","artifacts":{"Versions":{"0.8.23+commit.f704f362.Darwin.appleclang":"Versions.sol/Versions.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol":{"lastModificationDate":1701786778842,"contentHash":"86ef0154470f2f264e61fce225276ff9","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol"],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroEndpoint":{"0.8.23+commit.f704f362.Darwin.appleclang":"ILayerZeroEndpoint.sol/ILayerZeroEndpoint.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol":{"lastModificationDate":1701786778842,"contentHash":"ed9a0d4dbd5e18a6ced83725df0db4f3","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroReceiver":{"0.8.23+commit.f704f362.Darwin.appleclang":"ILayerZeroReceiver.sol/ILayerZeroReceiver.json"}}},"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol":{"lastModificationDate":1701786778842,"contentHash":"1e1af18cedcca5a5e82e96cdbe314d95","sourceName":"lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.5.0","artifacts":{"ILayerZeroUserApplicationConfig":{"0.8.23+commit.f704f362.Darwin.appleclang":"ILayerZeroUserApplicationConfig.sol/ILayerZeroUserApplicationConfig.json"}}},"lib/solidity-examples/contracts/lzApp/libs/LzLib.sol":{"lastModificationDate":1701786778842,"contentHash":"d9f2cc63e84dd0cd244a5adbbfcda44d","sourceName":"lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.6.0","artifacts":{"LzLib":{"0.8.23+commit.f704f362.Darwin.appleclang":"LzLib.sol/LzLib.json"}}},"lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol":{"lastModificationDate":1701786778842,"contentHash":"c01d06f3b912ce04398bd127bb069c0c","sourceName":"lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol"],"versionRequirement":"^0.8.0","artifacts":{"LZEndpointMock":{"0.8.23+commit.f704f362.Darwin.appleclang":"LZEndpointMock.sol/LZEndpointMock.json"}}},"lib/wormhole-solidity-sdk/src/Utils.sol":{"lastModificationDate":1701786778886,"contentHash":"8366c6827b67e28622f2d0c5ef530a95","sourceName":"lib/wormhole-solidity-sdk/src/Utils.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol"],"versionRequirement":"^0.8.13","artifacts":{"Utils":{"0.8.23+commit.f704f362.Darwin.appleclang":"Utils.sol/Utils.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol":{"lastModificationDate":1701786778887,"contentHash":"d3f395dc838796643e7a71419900ab23","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IERC20":{"0.8.23+commit.f704f362.Darwin.appleclang":"IERC20.sol/IERC20.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol":{"lastModificationDate":1701786778887,"contentHash":"effdc02941abf3d3e90d2e4c3e5fa6b5","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol"],"versionRequirement":"^0.8.0","artifacts":{"ITokenBridge":{"0.8.23+commit.f704f362.Darwin.appleclang":"ITokenBridge.sol/ITokenBridge.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol":{"lastModificationDate":1701786778887,"contentHash":"90020aa00c69797588ffd23484bab40b","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol"],"versionRequirement":"^0.8.0","artifacts":{"IWETH":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWETH.sol/IWETH.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol":{"lastModificationDate":1701786778887,"contentHash":"17bcb8ab1190b494435234940d3f7ba3","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormhole":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormhole.sol/IWormhole.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol":{"lastModificationDate":1701786778887,"contentHash":"45470d92c4bc6d2fea60e2a719d6fad5","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormholeReceiver":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeReceiver.sol/IWormholeReceiver.json"}}},"lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol":{"lastModificationDate":1701786778887,"contentHash":"f0c31126b4d7df3b1f7de5933a2d8755","sourceName":"lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.0","artifacts":{"IWormholeRelayer":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeRelayer.sol/IWormholeRelayer.json"},"IWormholeRelayerBase":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeRelayer.sol/IWormholeRelayerBase.json"},"IWormholeRelayerDelivery":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeRelayer.sol/IWormholeRelayerDelivery.json"},"IWormholeRelayerSend":{"0.8.23+commit.f704f362.Darwin.appleclang":"IWormholeRelayer.sol/IWormholeRelayerSend.json"}}},"lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol":{"lastModificationDate":1701786778888,"contentHash":"5dc3cd1df4ef5a5c06bfa77d5b0fb616","sourceName":"lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol"],"versionRequirement":"^0.8.13","artifacts":{"ERC20":{"0.8.23+commit.f704f362.Darwin.appleclang":"ERC20Mock.sol/ERC20.json"},"ERC20Mock":{"0.8.23+commit.f704f362.Darwin.appleclang":"ERC20Mock.sol/ERC20Mock.json"}}},"lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol":{"lastModificationDate":1701786778888,"contentHash":"3bad89b755087e6ae4db134e852cc048","sourceName":"lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeRelayerBasicTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"WormholeRelayerTest.sol/WormholeRelayerBasicTest.json"},"WormholeRelayerTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"WormholeRelayerTest.sol/WormholeRelayerTest.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol":{"lastModificationDate":1701786778888,"contentHash":"51df31343142a8bb61160161ee03a040","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0, <0.9.0","artifacts":{"BytesLib":{"0.8.23+commit.f704f362.Darwin.appleclang":"BytesLib.sol/BytesLib.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol":{"lastModificationDate":1701786778888,"contentHash":"84ab4b6332ff0bca993506b10843da47","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":"^0.8.13","artifacts":{"BytesParsing":{"0.8.23+commit.f704f362.Darwin.appleclang":"BytesParsing.sol/BytesParsing.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol":{"lastModificationDate":1701786778888,"contentHash":"7a3aa31b38d0bd707385cf4a109e2485","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol"],"versionRequirement":"^0.8.13","artifacts":{"DeliveryInstructionDecoder":{"0.8.23+commit.f704f362.Darwin.appleclang":"DeliveryInstructionDecoder.sol/DeliveryInstructionDecoder.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol":{"lastModificationDate":1701786778888,"contentHash":"c44b3c368d72d80f2f87ff26702d7c25","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol"],"versionRequirement":"^0.8.13","artifacts":{"ExecutionParameters":{"0.8.23+commit.f704f362.Darwin.appleclang":"ExecutionParameters.sol/ExecutionParameters.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol":{"lastModificationDate":1701786778888,"contentHash":"4ffa8667101e55084275186cf211e143","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol"],"versionRequirement":"^0.8.0","artifacts":{"MockOffchainRelayer":{"0.8.23+commit.f704f362.Darwin.appleclang":"MockOffchainRelayer.sol/MockOffchainRelayer.json"}}},"lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol":{"lastModificationDate":1701786778888,"contentHash":"bfcd29cb521141921f12a53bbd2be30e","sourceName":"lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeSimulator":{"0.8.23+commit.f704f362.Darwin.appleclang":"WormholeSimulator.sol/WormholeSimulator.json"}}},"library/utils/RLPDecodeStruct.sol":{"lastModificationDate":1714379207193,"contentHash":"d61a47c63bff5f73fe65d0a2aaee71bc","sourceName":"library/utils/RLPDecodeStruct.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"RLPDecodeStruct":{"0.8.23+commit.f704f362.Darwin.appleclang":"RLPDecodeStruct.sol/RLPDecodeStruct.json"}}},"library/utils/RLPEncodeStruct.sol":{"lastModificationDate":1714379207193,"contentHash":"4c80671dfcde6a86023ff997f9da5dd9","sourceName":"library/utils/RLPEncodeStruct.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"RLPEncodeStruct":{"0.8.23+commit.f704f362.Darwin.appleclang":"RLPEncodeStruct.sol/RLPEncodeStruct.json"}}},"library/utils/Types.sol":{"lastModificationDate":1714379207193,"contentHash":"749a5c0849e27051663dedf475d4840a","sourceName":"library/utils/Types.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/utils/RLPEncode.sol"],"versionRequirement":">=0.8.0","artifacts":{"Types":{"0.8.23+commit.f704f362.Darwin.appleclang":"Types.sol/Types.json"}}},"library/xcall/interfaces/IBSH.sol":{"lastModificationDate":1714379207193,"contentHash":"8fd4c949cdbf37dad2e7223d27b4d823","sourceName":"library/xcall/interfaces/IBSH.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IBSH":{"0.8.23+commit.f704f362.Darwin.appleclang":"IBSH.sol/IBSH.json"}}},"library/xcall/interfaces/ICallService.sol":{"lastModificationDate":1714379207194,"contentHash":"38a85024031afc083704b91cbb69d0df","sourceName":"library/xcall/interfaces/ICallService.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallService":{"0.8.23+commit.f704f362.Darwin.appleclang":"ICallService.sol/ICallService.json"}}},"library/xcall/interfaces/ICallServiceReceiver.sol":{"lastModificationDate":1714379207194,"contentHash":"2ca794c9547a409bda43e8cd9cddc21d","sourceName":"library/xcall/interfaces/ICallServiceReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallServiceReceiver":{"0.8.23+commit.f704f362.Darwin.appleclang":"ICallServiceReceiver.sol/ICallServiceReceiver.json"}}},"library/xcall/interfaces/ICallServiceV1.sol":{"lastModificationDate":1714379207194,"contentHash":"cbf6ad5b4b87689ab5cc6d0838150069","sourceName":"library/xcall/interfaces/ICallServiceV1.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ICallServiceV1":{"0.8.23+commit.f704f362.Darwin.appleclang":"ICallServiceV1.sol/ICallServiceV1.json"}}},"library/xcall/interfaces/IDefaultCallServiceReceiver.sol":{"lastModificationDate":1714379207194,"contentHash":"9ed4a1596fa1e5e72f7109dbab545534","sourceName":"library/xcall/interfaces/IDefaultCallServiceReceiver.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"IDefaultCallServiceReceiver":{"0.8.23+commit.f704f362.Darwin.appleclang":"IDefaultCallServiceReceiver.sol/IDefaultCallServiceReceiver.json"}}},"library/xcall/utils/Integers.sol":{"lastModificationDate":1714379207194,"contentHash":"e3d539bdfbc1bc771779239375c3885b","sourceName":"library/xcall/utils/Integers.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"Integers":{"0.8.23+commit.f704f362.Darwin.appleclang":"Integers.sol/Integers.json"}}},"library/xcall/utils/NetworkAddress.sol":{"lastModificationDate":1714379207194,"contentHash":"f834f12fc2e8e35a1cbfcda41d1e51d2","sourceName":"library/xcall/utils/NetworkAddress.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"NetworkAddress":{"0.8.23+commit.f704f362.Darwin.appleclang":"NetworkAddress.sol/NetworkAddress.json"}}},"library/xcall/utils/ParseAddress.sol":{"lastModificationDate":1714379207194,"contentHash":"717833bbbc0f961eda0f1b00dd1dec8c","sourceName":"library/xcall/utils/ParseAddress.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"ParseAddress":{"0.8.23+commit.f704f362.Darwin.appleclang":"ParseAddress.sol/ParseAddress.json"}}},"library/xcall/utils/RLPDecode.sol":{"lastModificationDate":1714379207195,"contentHash":"8a237d675ba6b1b4a7ff47dfcb229869","sourceName":"library/xcall/utils/RLPDecode.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"RLPDecode":{"0.8.23+commit.f704f362.Darwin.appleclang":"RLPDecode.sol/RLPDecode.json"}}},"library/xcall/utils/RLPEncode.sol":{"lastModificationDate":1714379207195,"contentHash":"3d288700d76882ab990800af30932805","sourceName":"library/xcall/utils/RLPEncode.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"RLPEncode":{"0.8.23+commit.f704f362.Darwin.appleclang":"RLPEncode.sol/RLPEncode.json"}}},"library/xcall/utils/Strings.sol":{"lastModificationDate":1714379207195,"contentHash":"15688932876357610555acf8dafa69d9","sourceName":"library/xcall/utils/Strings.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":[],"versionRequirement":">=0.8.0","artifacts":{"Strings":{"0.8.23+commit.f704f362.Darwin.appleclang":"Strings.sol/Strings.json"}}},"script/CallService.s.sol":{"lastModificationDate":1709554688286,"contentHash":"f21b7f9f99e65c98e05af8da9b980213","sourceName":"script/CallService.s.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/Script.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.18","artifacts":{"DeployCallService":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallService.s.sol/DeployCallService.json"}}},"script/XCallOperation.s.sol":{"lastModificationDate":1709554688286,"contentHash":"1258986ef23db12d4ad845b8398f0f3f","sourceName":"script/XCallOperation.s.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/Script.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/interfaces/IERC1967.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Utils.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/BeaconProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/IBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/beacon/UpgradeableBeacon.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Address.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts-upgradeable/lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-foundry-upgrades/lib/solidity-stringutils/strings.sol","lib/openzeppelin-foundry-upgrades/src/Upgrades.sol","lib/openzeppelin-foundry-upgrades/src/Versions.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":">=0.8.18","artifacts":{"WormholeTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"XCallOperation.s.sol/WormholeTest.json"}}},"test/adapters/CentralizedConnection.t.sol":{"lastModificationDate":1714379207196,"contentHash":"76e7d47b357b6bffb8d1dec5aebf6717","sourceName":"test/adapters/CentralizedConnection.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/CentralizedConnection.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CentralizedConnectionTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"CentralizedConnection.t.sol/CentralizedConnectionTest.json"}}},"test/adapters/ClusterConnection.t.sol":{"lastModificationDate":1728291046526,"contentHash":"485ac45f6828e9ae152c43d03d7f61d3","sourceName":"test/adapters/ClusterConnection.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/ClusterConnection.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"ClusterConnectionTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"ClusterConnection.t.sol/ClusterConnectionTest.json"}}},"test/adapters/LayerZeroAdapter.t.sol":{"lastModificationDate":1701785307138,"contentHash":"e01e83e6e99adf9eadc8e19dd1c12d07","sourceName":"test/adapters/LayerZeroAdapter.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/LayerZeroAdapter.sol","contracts/adapters/interfaces/ILayerZeroAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroEndpoint.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroReceiver.sol","lib/solidity-examples/contracts/lzApp/interfaces/ILayerZeroUserApplicationConfig.sol","lib/solidity-examples/contracts/lzApp/libs/LzLib.sol","lib/solidity-examples/contracts/lzApp/mocks/LZEndpointMock.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"LayerZeroAdapterTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"LayerZeroAdapter.t.sol/LayerZeroAdapterTest.json"}}},"test/adapters/WormholeAdapter.t.sol":{"lastModificationDate":1701785307138,"contentHash":"224f8073bc96bb1948fb15441a1c9050","sourceName":"test/adapters/WormholeAdapter.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/adapters/WormholeAdapter.sol","contracts/adapters/interfaces/IWormholeAdapter.sol","contracts/mocks/multi-protocol-dapp/MultiProtocolSampleDapp.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","lib/wormhole-solidity-sdk/src/Utils.sol","lib/wormhole-solidity-sdk/src/interfaces/IERC20.sol","lib/wormhole-solidity-sdk/src/interfaces/ITokenBridge.sol","lib/wormhole-solidity-sdk/src/interfaces/IWETH.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormhole.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeReceiver.sol","lib/wormhole-solidity-sdk/src/interfaces/IWormholeRelayer.sol","lib/wormhole-solidity-sdk/src/testing/ERC20Mock.sol","lib/wormhole-solidity-sdk/src/testing/WormholeRelayerTest.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesLib.sol","lib/wormhole-solidity-sdk/src/testing/helpers/BytesParsing.sol","lib/wormhole-solidity-sdk/src/testing/helpers/DeliveryInstructionDecoder.sol","lib/wormhole-solidity-sdk/src/testing/helpers/ExecutionParameters.sol","lib/wormhole-solidity-sdk/src/testing/helpers/MockOffchainRelayer.sol","lib/wormhole-solidity-sdk/src/testing/helpers/WormholeSimulator.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"WormholeAdapterTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"WormholeAdapter.t.sol/WormholeAdapterTest.json"}}},"test/xcall/CallService.t.sol":{"lastModificationDate":1714711378690,"contentHash":"8514d97f4e5eddea90053217cbef46fe","sourceName":"test/xcall/CallService.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/mocks/dapp/DAppProxySample.sol","contracts/xcall/CallService.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CallServiceTest":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallService.t.sol/CallServiceTest.json"},"ResponseContract":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallService.t.sol/ResponseContract.json"}}},"test/xcall/CallServiceV1.t.sol":{"lastModificationDate":1714711378690,"contentHash":"616f1567f33618bf0ead10bbc4e08745","sourceName":"test/xcall/CallServiceV1.t.sol","solcConfig":{"settings":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"":["ast"],"*":["abi","evm.bytecode","evm.deployedBytecode","evm.methodIdentifiers","metadata","storageLayout"]}},"evmVersion":"paris","libraries":{}}},"imports":["contracts/mocks/dapp/DAppProxySample.sol","contracts/xcall/CallServiceV1.sol","contracts/xcall/interfaces/IConnection.sol","contracts/xcall/interfaces/IFeeManage.sol","lib/forge-std/lib/ds-test/src/test.sol","lib/forge-std/src/Base.sol","lib/forge-std/src/StdAssertions.sol","lib/forge-std/src/StdChains.sol","lib/forge-std/src/StdCheats.sol","lib/forge-std/src/StdError.sol","lib/forge-std/src/StdInvariant.sol","lib/forge-std/src/StdJson.sol","lib/forge-std/src/StdMath.sol","lib/forge-std/src/StdStorage.sol","lib/forge-std/src/StdStyle.sol","lib/forge-std/src/StdUtils.sol","lib/forge-std/src/Test.sol","lib/forge-std/src/Vm.sol","lib/forge-std/src/console.sol","lib/forge-std/src/console2.sol","lib/forge-std/src/interfaces/IMulticall3.sol","lib/forge-std/src/safeconsole.sol","lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol","library/utils/RLPDecodeStruct.sol","library/utils/RLPEncodeStruct.sol","library/utils/Types.sol","library/xcall/interfaces/IBSH.sol","library/xcall/interfaces/ICallService.sol","library/xcall/interfaces/ICallServiceReceiver.sol","library/xcall/interfaces/ICallServiceV1.sol","library/xcall/interfaces/IDefaultCallServiceReceiver.sol","library/xcall/utils/Integers.sol","library/xcall/utils/NetworkAddress.sol","library/xcall/utils/ParseAddress.sol","library/xcall/utils/RLPDecode.sol","library/xcall/utils/RLPEncode.sol","library/xcall/utils/Strings.sol"],"versionRequirement":"^0.8.13","artifacts":{"CallServiceV1Test":{"0.8.23+commit.f704f362.Darwin.appleclang":"CallServiceV1.t.sol/CallServiceV1Test.json"}}}}} \ No newline at end of file