From b12f5c2179f337c722fb297141b908f8eae1c12d Mon Sep 17 00:00:00 2001 From: tbro Date: Mon, 10 Mar 2025 16:48:45 -0300 Subject: [PATCH 1/4] bump alloy to 0.12 --- Cargo.lock | 173 ++++++++++++++++++++++++++++++++--------------------- Cargo.toml | 2 +- 2 files changed, 106 insertions(+), 69 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index f59f544b13..2ccdfaa67e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -133,9 +133,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" [[package]] name = "alloy" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbcc41e8a11a4975b18ec6afba2cc48d591fa63336a4c526dacb50479a8d6b35" +checksum = "f438db4dcc20bd52223b3d5bc279b8394bc2488cf0176b5774950954d5c2c147" dependencies = [ "alloy-consensus", "alloy-contract", @@ -147,6 +147,7 @@ dependencies = [ "alloy-pubsub", "alloy-rpc-client", "alloy-rpc-types", + "alloy-serde", "alloy-signer", "alloy-signer-local", "alloy-transport", @@ -167,9 +168,9 @@ dependencies = [ [[package]] name = "alloy-consensus" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4138dc275554afa6f18c4217262ac9388790b2fc393c2dfe03c51d357abf013" +checksum = "1715ed2a977d3ca4b39ffe0fc69f9f5b0e81382b348bdb5172abaa77a10f0b6d" dependencies = [ "alloy-eips", "alloy-primitives", @@ -178,15 +179,21 @@ dependencies = [ "alloy-trie", "auto_impl", "c-kzg", - "derive_more 1.0.0", + "derive_more 2.0.1", + "either", + "k256", + "once_cell", + "rand 0.8.5", "serde", + "serde_with", + "thiserror 2.0.12", ] [[package]] name = "alloy-consensus-any" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fa04e1882c31288ce1028fdf31b6ea94cfa9eafa2e497f903ded631c8c6a42c" +checksum = "660705969af143897d83937d73f53c741c1587f49c27c2cfce594e188fcbc1e4" dependencies = [ "alloy-consensus", "alloy-eips", @@ -198,9 +205,9 @@ dependencies = [ [[package]] name = "alloy-contract" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f21886c1fea0626f755a49b2ac653b396fb345233f6170db2da3d0ada31560c" +checksum = "5362637b25ba5282a921ca139a10f188fa34e1248a7c83c907a21de54d36dce1" dependencies = [ "alloy-dyn-abi", "alloy-json-abi", @@ -246,6 +253,19 @@ dependencies = [ "winnow 0.7.3", ] +[[package]] +name = "alloy-eip2124" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "675264c957689f0fd75f5993a73123c2cc3b5c235a38f5b9037fe6c826bfb2c0" +dependencies = [ + "alloy-primitives", + "alloy-rlp", + "crc", + "serde", + "thiserror 2.0.12", +] + [[package]] name = "alloy-eip2930" version = "0.1.0" @@ -271,17 +291,20 @@ dependencies = [ [[package]] name = "alloy-eips" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52dd5869ed09e399003e0e0ec6903d981b2a92e74c5d37e6b40890bad2517526" +checksum = "d13734f722326c846e7690ce732c9864f5ae82f52c7fb60c871f56654f348d4c" dependencies = [ + "alloy-eip2124", "alloy-eip2930", "alloy-eip7702", "alloy-primitives", "alloy-rlp", "alloy-serde", + "auto_impl", "c-kzg", - "derive_more 1.0.0", + "derive_more 2.0.1", + "either", "once_cell", "serde", "sha2 0.10.8", @@ -301,9 +324,9 @@ dependencies = [ [[package]] name = "alloy-json-rpc" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2008bedb8159a255b46b7c8614516eda06679ea82f620913679afbd8031fea72" +checksum = "e6fbb61c4dfe5def9a065438162faf39503b3e8d90f36d01563418a75f0ef016" dependencies = [ "alloy-primitives", "alloy-sol-types", @@ -315,9 +338,9 @@ dependencies = [ [[package]] name = "alloy-network" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4556f01fe41d0677495df10a648ddcf7ce118b0e8aa9642a0e2b6dd1fb7259de" +checksum = "f10b0bc0657b018ee4f3758f889d066af6b1f20f57cd825b540182029090c151" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -332,6 +355,7 @@ dependencies = [ "alloy-sol-types", "async-trait", "auto_impl", + "derive_more 2.0.1", "futures-utils-wasm", "serde", "serde_json", @@ -340,9 +364,9 @@ dependencies = [ [[package]] name = "alloy-network-primitives" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f31c3c6b71340a1d076831823f09cb6e02de01de5c6630a9631bdb36f947ff80" +checksum = "6cac4aeeabbbc16623d0745ae3b5a515d727ce8ef4ec4b6a886c3634d8b298fe" dependencies = [ "alloy-consensus", "alloy-eips", @@ -380,9 +404,9 @@ dependencies = [ [[package]] name = "alloy-provider" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a22c4441b3ebe2d77fa9cf629ba68c3f713eb91779cff84275393db97eddd82" +checksum = "d06ffafc44e68c8244feb51919895c679c153a0b143c182e1ffe8cce998abf15" dependencies = [ "alloy-chains", "alloy-consensus", @@ -394,6 +418,7 @@ dependencies = [ "alloy-pubsub", "alloy-rpc-client", "alloy-rpc-types-eth", + "alloy-sol-types", "alloy-transport", "alloy-transport-http", "alloy-transport-ws", @@ -403,11 +428,10 @@ dependencies = [ "dashmap", "futures", "futures-utils-wasm", - "lru 0.12.5", + "lru 0.13.0", "parking_lot", "pin-project", "reqwest 0.12.12", - "schnellru", "serde", "serde_json", "thiserror 2.0.12", @@ -419,9 +443,9 @@ dependencies = [ [[package]] name = "alloy-pubsub" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2269fd635f7b505f27c63a3cb293148cd02301efce4c8bdd9ff54fbfc4a20e23" +checksum = "6abe9f9e6be75dc8532bb2bf3f4c700c9e7bce8a3b05ec702a7324abdb118016" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -460,9 +484,9 @@ dependencies = [ [[package]] name = "alloy-rpc-client" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d06a292b37e182e514903ede6e623b9de96420e8109ce300da288a96d88b7e4b" +checksum = "c9ae316fdb92a4546f0dba4919ea4c1c0edb89a876536520c248fada0febac5d" dependencies = [ "alloy-json-rpc", "alloy-primitives", @@ -485,9 +509,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9383845dd924939e7ab0298bbfe231505e20928907d7905aa3bf112287305e06" +checksum = "61e50cc5a693dfbef452e3dbcea3cd3342840d10eb3ffa018b0a5676967d8b6b" dependencies = [ "alloy-primitives", "alloy-rpc-types-eth", @@ -497,9 +521,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-any" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca445cef0eb6c2cf51cfb4e214fbf1ebd00893ae2e6f3b944c8101b07990f988" +checksum = "f726ebb03d5918a946d0a6e17829cabd90ffe928664dc3f7fdbba1be511760de" dependencies = [ "alloy-consensus-any", "alloy-rpc-types-eth", @@ -508,9 +532,9 @@ dependencies = [ [[package]] name = "alloy-rpc-types-eth" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0938bc615c02421bd86c1733ca7205cc3d99a122d9f9bff05726bd604b76a5c2" +checksum = "c24a3b6c552b74c4abdbaa45fd467a230f5564f62c6adae16972dd90b6b4dca5" dependencies = [ "alloy-consensus", "alloy-consensus-any", @@ -520,7 +544,7 @@ dependencies = [ "alloy-rlp", "alloy-serde", "alloy-sol-types", - "itertools 0.13.0", + "itertools 0.14.0", "serde", "serde_json", "thiserror 2.0.12", @@ -528,9 +552,9 @@ dependencies = [ [[package]] name = "alloy-serde" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae0465c71d4dced7525f408d84873aeebb71faf807d22d74c4a426430ccd9b55" +checksum = "3aebca035ca670bd7de8165a9494c0d502625e26129dd95d17fdfd70d5521c02" dependencies = [ "alloy-primitives", "serde", @@ -539,13 +563,14 @@ dependencies = [ [[package]] name = "alloy-signer" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9bfa395ad5cc952c82358d31e4c68b27bf4a89a5456d9b27e226e77dac50e4ff" +checksum = "7abfef2a155c7d6a9f54861159a3fdd29abe1f67f0865b081bce4c2fdc9e83cc" dependencies = [ "alloy-primitives", "async-trait", "auto_impl", + "either", "elliptic-curve", "k256", "thiserror 2.0.12", @@ -553,9 +578,9 @@ dependencies = [ [[package]] name = "alloy-signer-local" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbdc63ce9eda1283fcbaca66ba4a414b841c0e3edbeef9c86a71242fc9e84ccc" +checksum = "326033310c939b0d00b03fdbe2c243cb45add25c4e195d97b1792883c93a4c4c" dependencies = [ "alloy-consensus", "alloy-network", @@ -644,13 +669,12 @@ dependencies = [ [[package]] name = "alloy-transport" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d17722a198f33bbd25337660787aea8b8f57814febb7c746bc30407bdfc39448" +checksum = "463f6cb5234c7420e7e77c248c0460a8e2dea933f2bb4e8f169d5f12510b38e0" dependencies = [ "alloy-json-rpc", "base64 0.22.1", - "futures-util", "futures-utils-wasm", "serde", "serde_json", @@ -664,9 +688,9 @@ dependencies = [ [[package]] name = "alloy-transport-http" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e1509599021330a31c4a6816b655e34bf67acb1cc03c564e09fd8754ff6c5de" +checksum = "1eacd1c195c2a706bfbc92113d4bd3481b0dbd1742923a232dbe8a7910ac0fe5" dependencies = [ "alloy-json-rpc", "alloy-transport", @@ -679,9 +703,9 @@ dependencies = [ [[package]] name = "alloy-transport-ws" -version = "0.9.2" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58011745b2f17b334db40df9077d75b181f78360a5bc5c35519e15d4bfce15e2" +checksum = "218e64c375edd8fe8d00d9aa983fb2d85f7cfeebb91f707fe4c7ba52410803f5" dependencies = [ "alloy-pubsub", "alloy-transport", @@ -690,7 +714,7 @@ dependencies = [ "rustls 0.23.23", "serde_json", "tokio", - "tokio-tungstenite 0.24.0", + "tokio-tungstenite 0.26.2", "tracing", "ws_stream_wasm", ] @@ -3633,6 +3657,7 @@ dependencies = [ "digest 0.10.7", "elliptic-curve", "rfc6979", + "serdect", "signature", "spki", ] @@ -3670,9 +3695,9 @@ checksum = "e3f497e87b038c09a155dfd169faa5ec940d0644635555ef6bd464ac20e97397" [[package]] name = "either" -version = "1.14.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7914353092ddf589ad78f25c5c1c21b7f80b0ff8621e7c814c3485b5306da9d" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" dependencies = [ "serde", ] @@ -3692,6 +3717,7 @@ dependencies = [ "pkcs8", "rand_core 0.6.4", "sec1", + "serdect", "subtle", "zeroize", ] @@ -6751,6 +6777,7 @@ dependencies = [ "ecdsa", "elliptic-curve", "once_cell", + "serdect", "sha2 0.10.8", "signature", ] @@ -7443,6 +7470,15 @@ dependencies = [ "hashbrown 0.15.2", ] +[[package]] +name = "lru" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "227748d55f2f0ab4735d87fd623798cb6b664512fe979705f829c9f81c934465" +dependencies = [ + "hashbrown 0.15.2", +] + [[package]] name = "lru-cache" version = "0.1.2" @@ -8173,7 +8209,9 @@ version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8983bb634df7248924ee0c4c3a749609b5abcb082c28fffe3254b3eb3602b307" dependencies = [ + "alloy-rlp", "const-hex", + "proptest", "serde", "smallvec", ] @@ -10017,17 +10055,6 @@ dependencies = [ "windows-sys 0.59.0", ] -[[package]] -name = "schnellru" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "356285bbf17bea63d9e52e96bd18f039672ac92b55b8cb997d6162a2a37d1649" -dependencies = [ - "ahash 0.8.11", - "cfg-if", - "hashbrown 0.13.2", -] - [[package]] name = "scoped-tls" version = "1.0.1" @@ -10088,6 +10115,7 @@ dependencies = [ "der", "generic-array", "pkcs8", + "serdect", "subtle", "zeroize", ] @@ -10411,6 +10439,16 @@ dependencies = [ "syn 2.0.99", ] +[[package]] +name = "serdect" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177" +dependencies = [ + "base16ct", + "serde", +] + [[package]] name = "sha-1" version = "0.9.8" @@ -11809,9 +11847,9 @@ dependencies = [ [[package]] name = "tokio-tungstenite" -version = "0.24.0" +version = "0.26.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9" +checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084" dependencies = [ "futures-util", "log", @@ -11819,7 +11857,7 @@ dependencies = [ "rustls-pki-types", "tokio", "tokio-rustls 0.26.2", - "tungstenite 0.24.0", + "tungstenite 0.26.2", "webpki-roots 0.26.8", ] @@ -12215,21 +12253,20 @@ dependencies = [ [[package]] name = "tungstenite" -version = "0.24.0" +version = "0.26.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a" +checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13" dependencies = [ - "byteorder", "bytes 1.10.0", "data-encoding", "http 1.2.0", "httparse", "log", - "rand 0.8.5", + "rand 0.9.0", "rustls 0.23.23", "rustls-pki-types", "sha1 0.10.6", - "thiserror 1.0.69", + "thiserror 2.0.12", "utf-8", ] diff --git a/Cargo.toml b/Cargo.toml index ce2648d08f..dfd7f7104b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,7 +52,7 @@ exclude = ["sequencer-sqlite"] [workspace.dependencies] contract-bindings-alloy = { path = "./contract-bindings-alloy" } ethers-conv = { path = "./ethers-conv" } -alloy = { version = "0.9", default-features = false, features = [ +alloy = { version = "0.12", default-features = false, features = [ "contract", "eips", "json-rpc", From 66ce9b5cb40423fb6abae7c9c7ff78bad885c007 Mon Sep 17 00:00:00 2001 From: tbro Date: Tue, 11 Mar 2025 17:52:27 -0300 Subject: [PATCH 2/4] remove `with_recommended_fillers This is now the default` --- utils/src/deployer.rs | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/utils/src/deployer.rs b/utils/src/deployer.rs index 6bb4702413..76b4e446b3 100644 --- a/utils/src/deployer.rs +++ b/utils/src/deployer.rs @@ -342,10 +342,7 @@ pub async fn deploy( .build()? .with_chain_id(Some(chain_id)); let wallet_alloy = EthereumWallet::from(signer_alloy); - let l1_alloy = ProviderBuilder::new() - .with_recommended_fillers() - .wallet(wallet_alloy) - .on_http(l1url); + let l1_alloy = ProviderBuilder::new().wallet(wallet_alloy).on_http(l1url); // As a sanity check, check that the deployer address has some balance of ETH it can use to pay // gas. From c98de194906c7d79cebe337615685f309a3e6871 Mon Sep 17 00:00:00 2001 From: tbro Date: Thu, 13 Mar 2025 08:59:12 -0300 Subject: [PATCH 3/4] regenerate alloy bindings --- contract-bindings-alloy/Cargo.toml | 2 +- contract-bindings-alloy/src/erc1967proxy.rs | 424 +- contract-bindings-alloy/src/feecontract.rs | 2369 ++++++--- contract-bindings-alloy/src/iplonkverifier.rs | 1119 ++-- contract-bindings-alloy/src/lightclient.rs | 4334 ++++++++++------ .../src/lightclientarbitrum.rs | 4022 ++++++++++----- .../src/lightclientmock.rs | 4481 +++++++++++------ .../src/permissionedstaketable.rs | 1813 ++++--- contract-bindings-alloy/src/plonkverifier.rs | 1303 +++-- contract-bindings-alloy/src/plonkverifier2.rs | 1323 +++-- 10 files changed, 13793 insertions(+), 7397 deletions(-) diff --git a/contract-bindings-alloy/Cargo.toml b/contract-bindings-alloy/Cargo.toml index 0bf65b1058..ef453a8b8b 100644 --- a/contract-bindings-alloy/Cargo.toml +++ b/contract-bindings-alloy/Cargo.toml @@ -4,4 +4,4 @@ version = "0.1.0" edition = "2021" [dependencies] -alloy = { workspace = true } +alloy = { git = "https://github.com/alloy-rs/alloy", features = ["sol-types", "contract"] } \ No newline at end of file diff --git a/contract-bindings-alloy/src/erc1967proxy.rs b/contract-bindings-alloy/src/erc1967proxy.rs index d8c58c39fd..e996142651 100644 --- a/contract-bindings-alloy/src/erc1967proxy.rs +++ b/contract-bindings-alloy/src/erc1967proxy.rs @@ -94,9 +94,8 @@ interface ERC1967Proxy { clippy::empty_structs_with_brackets )] pub mod ERC1967Proxy { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -118,9 +117,9 @@ pub mod ERC1967Proxy { b"`\x80`@R`\n`\x0CV[\0[`\x18`\x14`\x1AV[`PV[V[_`K\x7F6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBCT`\x01`\x01`\xA0\x1B\x03\x16\x90V[\x90P\x90V[6_\x807_\x806_\x84Z\xF4=_\x80>\x80\x80\x15`iW=_\xF3[=_\xFD\xFE\xA1dsolcC\0\x08\x17\0\n", ); /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`. - ```solidity - error AddressEmptyCode(address target); - ```*/ +```solidity +error AddressEmptyCode(address target); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct AddressEmptyCode { @@ -141,11 +140,13 @@ pub mod ERC1967Proxy { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -165,7 +166,9 @@ pub mod ERC1967Proxy { #[automatically_derived] impl alloy_sol_types::SolError for AddressEmptyCode { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "AddressEmptyCode(address)"; const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8]; #[inline] @@ -185,9 +188,9 @@ pub mod ERC1967Proxy { } }; /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`. - ```solidity - error ERC1967InvalidImplementation(address implementation); - ```*/ +```solidity +error ERC1967InvalidImplementation(address implementation); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967InvalidImplementation { @@ -208,33 +211,37 @@ pub mod ERC1967Proxy { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: ERC1967InvalidImplementation) -> Self { (value.implementation,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for ERC1967InvalidImplementation { + impl ::core::convert::From> + for ERC1967InvalidImplementation { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - implementation: tuple.0, - } + Self { implementation: tuple.0 } } } #[automatically_derived] impl alloy_sol_types::SolError for ERC1967InvalidImplementation { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)"; const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8]; #[inline] @@ -254,9 +261,9 @@ pub mod ERC1967Proxy { } }; /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`. - ```solidity - error ERC1967NonPayable(); - ```*/ +```solidity +error ERC1967NonPayable(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967NonPayable {} @@ -274,11 +281,13 @@ pub mod ERC1967Proxy { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -298,7 +307,9 @@ pub mod ERC1967Proxy { #[automatically_derived] impl alloy_sol_types::SolError for ERC1967NonPayable { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967NonPayable()"; const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8]; #[inline] @@ -314,9 +325,9 @@ pub mod ERC1967Proxy { } }; /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`. - ```solidity - error FailedInnerCall(); - ```*/ +```solidity +error FailedInnerCall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FailedInnerCall {} @@ -334,11 +345,13 @@ pub mod ERC1967Proxy { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -358,7 +371,9 @@ pub mod ERC1967Proxy { #[automatically_derived] impl alloy_sol_types::SolError for FailedInnerCall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FailedInnerCall()"; const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8]; #[inline] @@ -374,9 +389,9 @@ pub mod ERC1967Proxy { } }; /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. - ```solidity - event Upgraded(address indexed implementation); - ```*/ +```solidity +event Upgraded(address indexed implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -399,18 +414,48 @@ pub mod ERC1967Proxy { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgraded { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Upgraded(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, - 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, - 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -418,20 +463,20 @@ pub mod ERC1967Proxy { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: topics.1, - } + Self { implementation: topics.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -451,7 +496,9 @@ pub mod ERC1967Proxy { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.implementation, ); @@ -476,9 +523,9 @@ pub mod ERC1967Proxy { } }; /**Constructor`. - ```solidity - constructor(address implementation, bytes _data) payable; - ```*/ +```solidity +constructor(address implementation, bytes _data) payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct constructorCall { @@ -502,11 +549,13 @@ pub mod ERC1967Proxy { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -533,7 +582,9 @@ pub mod ERC1967Proxy { alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Bytes, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -589,16 +640,16 @@ pub mod ERC1967Proxy { match self { Self::AddressEmptyCode(_) => { ::SELECTOR - }, + } Self::ERC1967InvalidImplementation(_) => { ::SELECTOR - }, + } Self::ERC1967NonPayable(_) => { ::SELECTOR - }, + } Self::FailedInnerCall(_) => { ::SELECTOR - }, + } } } #[inline] @@ -619,17 +670,17 @@ pub mod ERC1967Proxy { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn FailedInnerCall( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(ERC1967ProxyErrors::FailedInnerCall) + data, + validate, + ) + .map(ERC1967ProxyErrors::FailedInnerCall) } FailedInnerCall }, @@ -639,9 +690,10 @@ pub mod ERC1967Proxy { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(ERC1967ProxyErrors::ERC1967InvalidImplementation) + data, + validate, + ) + .map(ERC1967ProxyErrors::ERC1967InvalidImplementation) } ERC1967InvalidImplementation }, @@ -651,9 +703,10 @@ pub mod ERC1967Proxy { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(ERC1967ProxyErrors::AddressEmptyCode) + data, + validate, + ) + .map(ERC1967ProxyErrors::AddressEmptyCode) } AddressEmptyCode }, @@ -663,18 +716,21 @@ pub mod ERC1967Proxy { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(ERC1967ProxyErrors::ERC1967NonPayable) + data, + validate, + ) + .map(ERC1967ProxyErrors::ERC1967NonPayable) } ERC1967NonPayable }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -682,38 +738,54 @@ pub mod ERC1967Proxy { fn abi_encoded_size(&self) -> usize { match self { Self::AddressEmptyCode(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::ERC1967InvalidImplementation(inner) => { ::abi_encoded_size( inner, ) - }, + } Self::ERC1967NonPayable(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::FailedInnerCall(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::AddressEmptyCode(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::ERC1967InvalidImplementation(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::ERC1967NonPayable(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::FailedInnerCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -730,11 +802,42 @@ pub mod ERC1967Proxy { /// No guarantees are made about the order of the selectors. /// /// Prefer using `SolInterface` methods instead. - pub const SELECTORS: &'static [[u8; 32usize]] = &[[ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8, 32u8, - 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8, 91u8, - 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]]; + pub const SELECTORS: &'static [[u8; 32usize]] = &[ + [ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ], + ]; } #[automatically_derived] impl alloy_sol_types::SolEventInterface for ERC1967ProxyEvents { @@ -747,18 +850,24 @@ pub mod ERC1967Proxy { ) -> alloy_sol_types::Result { match topics.first().copied() { Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgraded) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -766,21 +875,23 @@ pub mod ERC1967Proxy { impl alloy_sol_types::private::IntoLogData for ERC1967ProxyEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { - Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { Self::Upgraded(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`ERC1967Proxy`](self) contract instance. - See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ +See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -794,9 +905,9 @@ pub mod ERC1967Proxy { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -806,15 +917,16 @@ pub mod ERC1967Proxy { provider: P, implementation: alloy::sol_types::private::Address, _data: alloy::sol_types::private::Bytes, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { ERC1967ProxyInstance::::deploy(provider, implementation, _data) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -829,15 +941,15 @@ pub mod ERC1967Proxy { } /**A [`ERC1967Proxy`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`ERC1967Proxy`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`ERC1967Proxy`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct ERC1967ProxyInstance { address: alloy_sol_types::private::Address, @@ -848,24 +960,24 @@ pub mod ERC1967Proxy { impl ::core::fmt::Debug for ERC1967ProxyInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("ERC1967ProxyInstance") - .field(&self.address) - .finish() + f.debug_tuple("ERC1967ProxyInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC1967ProxyInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { /**Creates a new wrapper around an on-chain [`ERC1967Proxy`](self) contract instance. - See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ +See the [wrapper's documentation](`ERC1967ProxyInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -874,9 +986,9 @@ pub mod ERC1967Proxy { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -888,10 +1000,10 @@ pub mod ERC1967Proxy { Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder( provider: P, @@ -902,13 +1014,15 @@ pub mod ERC1967Proxy { provider, [ &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { - implementation, - _data, - })[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + implementation, + _data, + }, + )[..], ] - .concat() - .into(), + .concat() + .into(), ) } /// Returns a reference to the address. @@ -946,11 +1060,10 @@ pub mod ERC1967Proxy { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC1967ProxyInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -965,11 +1078,10 @@ pub mod ERC1967Proxy { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > ERC1967ProxyInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > ERC1967ProxyInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. diff --git a/contract-bindings-alloy/src/feecontract.rs b/contract-bindings-alloy/src/feecontract.rs index 19aba5e2fd..480f5ed526 100644 --- a/contract-bindings-alloy/src/feecontract.rs +++ b/contract-bindings-alloy/src/feecontract.rs @@ -445,9 +445,8 @@ interface FeeContract { clippy::empty_structs_with_brackets )] pub mod FeeContract { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -469,9 +468,9 @@ pub mod FeeContract { b"`\x80`@R`\x046\x10a\0\xAAW_5`\xE0\x1C\x80c\x8D\xA5\xCB[\x11a\0cW\x80c\x8D\xA5\xCB[\x14a\x01\x9CW\x80c\x8E\xD82q\x14a\x01\xE2W\x80c\xAD<\xB1\xCC\x14a\x01\xF6W\x80c\xC4\xD6m\xE8\x14a\x023W\x80c\xF2\xFD\xE3\x8B\x14a\x02RW\x80c\xF3@\xFA\x01\x14a\x02qWa\0\xC8V[\x80c\r\x8En,\x14a\0\xE1W\x80c'\xE25\xE3\x14a\x01\x11W\x80cO\x1E\xF2\x86\x14a\x01JW\x80cR\xD1\x90-\x14a\x01_W\x80cdP\x06\xCA\x14a\x01sW\x80cqP\x18\xA6\x14a\x01\x88Wa\0\xC8V[6a\0\xC8W`@Qc\xBC\x8E\xCA\x1B`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Qc\x155\xAC_`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[4\x80\x15a\0\xECW_\x80\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\x1CW_\x80\xFD[Pa\x01W_\x80\xFD[Pa\x01]a\x02M6`\x04a\n0V[a\x02\xD1V[4\x80\x15a\x02]W_\x80\xFD[Pa\x01]a\x02l6`\x04a\n0V[a\x03\xFDV[a\x01]a\x02\x7F6`\x04a\n0V[a\x04?V[a\x02\x8Ca\x05\x18V[a\x02\x95\x82a\x05\xBCV[a\x02\x9F\x82\x82a\x06\x03V[PPV[_a\x02\xACa\x06\xC4V[P_\x80Q` a\x0B\xBF\x839\x81Q\x91R\x90V[a\x02\xC6a\x07\rV[a\x02\xCF_a\x07hV[V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x03\x16WP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x032WP0;\x15[\x90P\x81\x15\x80\x15a\x03@WP\x80\x15[\x15a\x03^W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x03\x88W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x03\x91\x86a\x07\xD8V[a\x03\x99a\x07\xE9V[g\r\xE0\xB6\xB3\xA7d\0\0_Uf\x03\x8D~\xA4\xC6\x80\0`\x01U\x83\x15a\x03\xF5W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPV[a\x04\x05a\x07\rV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x043W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x04<\x81a\x07hV[PV[`\x01T4\x10\x15a\x04bW`@Qck\xA4\xA1\xC7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_T4\x11\x15a\x04\x84W`@Qc\xC5mF\xD3`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x04\xABW`@Qc\x07\x02\xB3\xD9`\xE4\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x02` R`@\x81 \x80T4\x92\x90a\x04\xD2\x90\x84\x90a\x0BmV[\x90\x91UPP`@Q4\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16\x90\x7F\xE1\xFF\xFC\xC4\x92=\x04\xB5Y\xF4\xD2\x9A\x8B\xFCl\xDA\x04\xEB[\rF\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05\xC4a\x07\rV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01`@Q\x80\x91\x03\x90\xA1PV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x06]WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x06Z\x91\x81\x01\x90a\x0B\x8CV[`\x01[a\x06\x85W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x04*V[_\x80Q` a\x0B\xBF\x839\x81Q\x91R\x81\x14a\x06\xB5W`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x04*V[a\x06\xBF\x83\x83a\x07\xF1V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x02\xCFW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[3a\x07?\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x02\xCFW`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x04*V[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\x07\xE0a\x08FV[a\x04<\x81a\x08\x8FV[a\x02\xCFa\x08FV[a\x07\xFA\x82a\x08\x97V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x08>Wa\x06\xBF\x82\x82a\x08\xFAV[a\x02\x9Fa\tnV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x02\xCFW`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x04\x05a\x08FV[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x08\xCCW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x04*V[_\x80Q` a\x0B\xBF\x839\x81Q\x91R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``_\x80\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\t\x16\x91\x90a\x0B\xA3V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\tNW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\tSV[``\x91P[P\x91P\x91Pa\tc\x85\x83\x83a\t\x8DV[\x92PPP[\x92\x91PPV[4\x15a\x02\xCFW`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\t\xA2Wa\t\x9D\x82a\t\xECV[a\t\xE5V[\x81Q\x15\x80\x15a\t\xB9WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\t\xE2W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x04*V[P\x80[\x93\x92PPPV[\x80Q\x15a\t\xFCW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\n+W_\x80\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\n@W_\x80\xFD[a\t\xE5\x82a\n\x15V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_\x80`@\x83\x85\x03\x12\x15a\nnW_\x80\xFD[a\nw\x83a\n\x15V[\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\n\x93W_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\n\xA6W_\x80\xFD[\x815\x81\x81\x11\x15a\n\xB8Wa\n\xB8a\nIV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01\x90\x83\x82\x11\x81\x83\x10\x17\x15a\n\xE0Wa\n\xE0a\nIV[\x81`@R\x82\x81R\x88` \x84\x87\x01\x01\x11\x15a\n\xF8W_\x80\xFD[\x82` \x86\x01` \x83\x017_` \x84\x83\x01\x01R\x80\x95PPPPPP\x92P\x92\x90PV[_[\x83\x81\x10\x15a\x0B3W\x81\x81\x01Q\x83\x82\x01R` \x01a\x0B\x1BV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra\x0BY\x81`@\x85\x01` \x87\x01a\x0B\x19V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80\x82\x01\x80\x82\x11\x15a\thWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[_` \x82\x84\x03\x12\x15a\x0B\x9CW_\x80\xFD[PQ\x91\x90PV[_\x82Qa\x0B\xB4\x81\x84` \x87\x01a\x0B\x19V[\x91\x90\x91\x01\x92\x91PPV\xFE6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x17\0\n", ); /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`. - ```solidity - error AddressEmptyCode(address target); - ```*/ +```solidity +error AddressEmptyCode(address target); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct AddressEmptyCode { @@ -492,11 +491,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -516,7 +517,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for AddressEmptyCode { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "AddressEmptyCode(address)"; const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8]; #[inline] @@ -536,9 +539,9 @@ pub mod FeeContract { } }; /**Custom error with signature `DepositTooLarge()` and selector `0xc56d46d3`. - ```solidity - error DepositTooLarge(); - ```*/ +```solidity +error DepositTooLarge(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct DepositTooLarge {} @@ -556,11 +559,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -580,7 +585,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for DepositTooLarge { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "DepositTooLarge()"; const SELECTOR: [u8; 4] = [197u8, 109u8, 70u8, 211u8]; #[inline] @@ -596,9 +603,9 @@ pub mod FeeContract { } }; /**Custom error with signature `DepositTooSmall()` and selector `0x6ba4a1c7`. - ```solidity - error DepositTooSmall(); - ```*/ +```solidity +error DepositTooSmall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct DepositTooSmall {} @@ -616,11 +623,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -640,7 +649,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for DepositTooSmall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "DepositTooSmall()"; const SELECTOR: [u8; 4] = [107u8, 164u8, 161u8, 199u8]; #[inline] @@ -656,9 +667,9 @@ pub mod FeeContract { } }; /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`. - ```solidity - error ERC1967InvalidImplementation(address implementation); - ```*/ +```solidity +error ERC1967InvalidImplementation(address implementation); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967InvalidImplementation { @@ -679,33 +690,37 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: ERC1967InvalidImplementation) -> Self { (value.implementation,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for ERC1967InvalidImplementation { + impl ::core::convert::From> + for ERC1967InvalidImplementation { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - implementation: tuple.0, - } + Self { implementation: tuple.0 } } } #[automatically_derived] impl alloy_sol_types::SolError for ERC1967InvalidImplementation { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)"; const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8]; #[inline] @@ -725,9 +740,9 @@ pub mod FeeContract { } }; /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`. - ```solidity - error ERC1967NonPayable(); - ```*/ +```solidity +error ERC1967NonPayable(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967NonPayable {} @@ -745,11 +760,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -769,7 +786,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for ERC1967NonPayable { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967NonPayable()"; const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8]; #[inline] @@ -785,9 +804,9 @@ pub mod FeeContract { } }; /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`. - ```solidity - error FailedInnerCall(); - ```*/ +```solidity +error FailedInnerCall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FailedInnerCall {} @@ -805,11 +824,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -829,7 +850,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for FailedInnerCall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FailedInnerCall()"; const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8]; #[inline] @@ -845,9 +868,9 @@ pub mod FeeContract { } }; /**Custom error with signature `FunctionDoesNotExist()` and selector `0xa9ad62f8`. - ```solidity - error FunctionDoesNotExist(); - ```*/ +```solidity +error FunctionDoesNotExist(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FunctionDoesNotExist {} @@ -865,11 +888,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -889,7 +914,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for FunctionDoesNotExist { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FunctionDoesNotExist()"; const SELECTOR: [u8; 4] = [169u8, 173u8, 98u8, 248u8]; #[inline] @@ -905,9 +932,9 @@ pub mod FeeContract { } }; /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`. - ```solidity - error InvalidInitialization(); - ```*/ +```solidity +error InvalidInitialization(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidInitialization {} @@ -925,11 +952,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -949,7 +978,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for InvalidInitialization { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidInitialization()"; const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8]; #[inline] @@ -965,9 +996,9 @@ pub mod FeeContract { } }; /**Custom error with signature `InvalidUserAddress()` and selector `0x702b3d90`. - ```solidity - error InvalidUserAddress(); - ```*/ +```solidity +error InvalidUserAddress(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidUserAddress {} @@ -985,11 +1016,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1009,7 +1042,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for InvalidUserAddress { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidUserAddress()"; const SELECTOR: [u8; 4] = [112u8, 43u8, 61u8, 144u8]; #[inline] @@ -1025,9 +1060,9 @@ pub mod FeeContract { } }; /**Custom error with signature `NoFunctionCalled()` and selector `0xbc8eca1b`. - ```solidity - error NoFunctionCalled(); - ```*/ +```solidity +error NoFunctionCalled(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NoFunctionCalled {} @@ -1045,11 +1080,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1069,7 +1106,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for NoFunctionCalled { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NoFunctionCalled()"; const SELECTOR: [u8; 4] = [188u8, 142u8, 202u8, 27u8]; #[inline] @@ -1085,9 +1124,9 @@ pub mod FeeContract { } }; /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`. - ```solidity - error NotInitializing(); - ```*/ +```solidity +error NotInitializing(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NotInitializing {} @@ -1105,11 +1144,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1129,7 +1170,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for NotInitializing { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NotInitializing()"; const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8]; #[inline] @@ -1145,9 +1188,9 @@ pub mod FeeContract { } }; /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`. - ```solidity - error OwnableInvalidOwner(address owner); - ```*/ +```solidity +error OwnableInvalidOwner(address owner); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableInvalidOwner { @@ -1168,11 +1211,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1192,7 +1237,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for OwnableInvalidOwner { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableInvalidOwner(address)"; const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8]; #[inline] @@ -1212,9 +1259,9 @@ pub mod FeeContract { } }; /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`. - ```solidity - error OwnableUnauthorizedAccount(address account); - ```*/ +```solidity +error OwnableUnauthorizedAccount(address account); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableUnauthorizedAccount { @@ -1235,23 +1282,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: OwnableUnauthorizedAccount) -> Self { (value.account,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for OwnableUnauthorizedAccount { + impl ::core::convert::From> + for OwnableUnauthorizedAccount { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { account: tuple.0 } } @@ -1259,7 +1310,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for OwnableUnauthorizedAccount { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)"; const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8]; #[inline] @@ -1279,9 +1332,9 @@ pub mod FeeContract { } }; /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`. - ```solidity - error UUPSUnauthorizedCallContext(); - ```*/ +```solidity +error UUPSUnauthorizedCallContext(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnauthorizedCallContext {} @@ -1299,23 +1352,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnauthorizedCallContext) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnauthorizedCallContext { + impl ::core::convert::From> + for UUPSUnauthorizedCallContext { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -1323,7 +1380,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()"; const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8]; #[inline] @@ -1339,9 +1398,9 @@ pub mod FeeContract { } }; /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`. - ```solidity - error UUPSUnsupportedProxiableUUID(bytes32 slot); - ```*/ +```solidity +error UUPSUnsupportedProxiableUUID(bytes32 slot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnsupportedProxiableUUID { @@ -1362,23 +1421,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnsupportedProxiableUUID) -> Self { (value.slot,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnsupportedProxiableUUID { + impl ::core::convert::From> + for UUPSUnsupportedProxiableUUID { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { slot: tuple.0 } } @@ -1386,7 +1449,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)"; const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8]; #[inline] @@ -1406,9 +1471,9 @@ pub mod FeeContract { } }; /**Event with signature `Deposit(address,uint256)` and selector `0xe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c`. - ```solidity - event Deposit(address indexed user, uint256 amount); - ```*/ +```solidity +event Deposit(address indexed user, uint256 amount); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1433,18 +1498,48 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolEvent for Deposit { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Deposit(address,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8, 154u8, - 139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8, 7u8, 81u8, - 194u8, 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 225u8, + 255u8, + 252u8, + 196u8, + 146u8, + 61u8, + 4u8, + 181u8, + 89u8, + 244u8, + 210u8, + 154u8, + 139u8, + 252u8, + 108u8, + 218u8, + 4u8, + 235u8, + 91u8, + 13u8, + 60u8, + 70u8, + 7u8, + 81u8, + 194u8, + 64u8, + 44u8, + 92u8, + 92u8, + 201u8, + 16u8, + 156u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1462,20 +1557,22 @@ pub mod FeeContract { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.amount, - ), + as alloy_sol_types::SolType>::tokenize(&self.amount), ) } #[inline] @@ -1490,7 +1587,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.user, ); @@ -1515,9 +1614,9 @@ pub mod FeeContract { } }; /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`. - ```solidity - event Initialized(uint64 version); - ```*/ +```solidity +event Initialized(uint64 version); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1540,15 +1639,45 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolEvent for Initialized { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Initialized(uint64)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1563,20 +1692,22 @@ pub mod FeeContract { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.version, - ), + as alloy_sol_types::SolType>::tokenize(&self.version), ) } #[inline] @@ -1591,7 +1722,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -1613,9 +1746,9 @@ pub mod FeeContract { } }; /**Event with signature `Log(string,uint256)` and selector `0xdd970dd9b5bfe707922155b058a407655cb18288b807e2216442bca8ad83d6b5`. - ```solidity - event Log(string func, uint256 gas); - ```*/ +```solidity +event Log(string func, uint256 gas); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1643,15 +1776,45 @@ pub mod FeeContract { alloy::sol_types::sol_data::String, alloy::sol_types::sol_data::Uint<256>, ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Log(string,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 221u8, 151u8, 13u8, 217u8, 181u8, 191u8, 231u8, 7u8, 146u8, 33u8, 85u8, 176u8, - 88u8, 164u8, 7u8, 101u8, 92u8, 177u8, 130u8, 136u8, 184u8, 7u8, 226u8, 33u8, - 100u8, 66u8, 188u8, 168u8, 173u8, 131u8, 214u8, 181u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 221u8, + 151u8, + 13u8, + 217u8, + 181u8, + 191u8, + 231u8, + 7u8, + 146u8, + 33u8, + 85u8, + 176u8, + 88u8, + 164u8, + 7u8, + 101u8, + 92u8, + 177u8, + 130u8, + 136u8, + 184u8, + 7u8, + 226u8, + 33u8, + 100u8, + 66u8, + 188u8, + 168u8, + 173u8, + 131u8, + 214u8, + 181u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1659,21 +1822,20 @@ pub mod FeeContract { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - func: data.0, - gas: data.1, - } + Self { func: data.0, gas: data.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -1683,9 +1845,9 @@ pub mod FeeContract { ::tokenize( &self.func, ), - as alloy_sol_types::SolType>::tokenize( - &self.gas, - ), + as alloy_sol_types::SolType>::tokenize(&self.gas), ) } #[inline] @@ -1700,7 +1862,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -1722,9 +1886,9 @@ pub mod FeeContract { } }; /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. - ```solidity - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - ```*/ +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1749,19 +1913,49 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolEvent for OwnershipTransferred { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, - 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, - 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1779,11 +1973,13 @@ pub mod FeeContract { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -1807,7 +2003,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.previousOwner, ); @@ -1835,9 +2033,9 @@ pub mod FeeContract { } }; /**Event with signature `Upgrade(address)` and selector `0xf78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d`. - ```solidity - event Upgrade(address implementation); - ```*/ +```solidity +event Upgrade(address implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1860,15 +2058,45 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgrade { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Upgrade(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, - 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1876,20 +2104,20 @@ pub mod FeeContract { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: data.0, - } + Self { implementation: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -1913,7 +2141,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -1935,9 +2165,9 @@ pub mod FeeContract { } }; /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. - ```solidity - event Upgraded(address indexed implementation); - ```*/ +```solidity +event Upgraded(address indexed implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -1960,18 +2190,48 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgraded { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Upgraded(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, - 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, - 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -1979,20 +2239,20 @@ pub mod FeeContract { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: topics.1, - } + Self { implementation: topics.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -2012,7 +2272,9 @@ pub mod FeeContract { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.implementation, ); @@ -2037,9 +2299,9 @@ pub mod FeeContract { } }; /**Constructor`. - ```solidity - constructor(); - ```*/ +```solidity +constructor(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct constructorCall {} @@ -2052,11 +2314,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2077,7 +2341,9 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolConstructor for constructorCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -2091,9 +2357,9 @@ pub mod FeeContract { } }; /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`. - ```solidity - function UPGRADE_INTERFACE_VERSION() external view returns (string memory); - ```*/ +```solidity +function UPGRADE_INTERFACE_VERSION() external view returns (string memory); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UPGRADE_INTERFACE_VERSIONCall {} @@ -2119,23 +2385,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONCall { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -2148,23 +2418,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONReturn { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -2173,10 +2447,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = UPGRADE_INTERFACE_VERSIONReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()"; const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8]; #[inline] @@ -2194,17 +2472,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `balances(address)` and selector `0x27e235e3`. - ```solidity - function balances(address user) external view returns (uint256 amount); - ```*/ +```solidity +function balances(address user) external view returns (uint256 amount); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct balancesCall { @@ -2233,11 +2511,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2259,14 +2539,18 @@ pub mod FeeContract { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2287,10 +2571,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for balancesCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = balancesReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "balances(address)"; const SELECTOR: [u8; 4] = [39u8, 226u8, 53u8, 227u8]; #[inline] @@ -2312,17 +2600,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `deposit(address)` and selector `0xf340fa01`. - ```solidity - function deposit(address user) external payable; - ```*/ +```solidity +function deposit(address user) external payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct depositCall { @@ -2348,11 +2636,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2377,11 +2667,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2402,10 +2694,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for depositCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = depositReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "deposit(address)"; const SELECTOR: [u8; 4] = [243u8, 64u8, 250u8, 1u8]; #[inline] @@ -2427,17 +2723,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getVersion()` and selector `0x0d8e6e2c`. - ```solidity - function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); - ```*/ +```solidity +function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getVersionCall {} @@ -2467,11 +2763,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2500,11 +2798,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (u8, u8, u8); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2529,14 +2829,18 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for getVersionCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getVersionReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getVersion()"; const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8]; #[inline] @@ -2554,17 +2858,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initialize(address)` and selector `0xc4d66de8`. - ```solidity - function initialize(address multisig) external; - ```*/ +```solidity +function initialize(address multisig) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializeCall { @@ -2590,11 +2894,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2619,11 +2925,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2644,10 +2952,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for initializeCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initialize(address)"; const SELECTOR: [u8; 4] = [196u8, 214u8, 109u8, 232u8]; #[inline] @@ -2669,17 +2981,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `maxDepositAmount()` and selector `0x8ed83271`. - ```solidity - function maxDepositAmount() external view returns (uint256); - ```*/ +```solidity +function maxDepositAmount() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct maxDepositAmountCall {} @@ -2705,23 +3017,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: maxDepositAmountCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for maxDepositAmountCall { + impl ::core::convert::From> + for maxDepositAmountCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -2731,26 +3047,32 @@ pub mod FeeContract { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: maxDepositAmountReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for maxDepositAmountReturn { + impl ::core::convert::From> + for maxDepositAmountReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -2759,10 +3081,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for maxDepositAmountCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = maxDepositAmountReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "maxDepositAmount()"; const SELECTOR: [u8; 4] = [142u8, 216u8, 50u8, 113u8]; #[inline] @@ -2780,17 +3106,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `minDepositAmount()` and selector `0x645006ca`. - ```solidity - function minDepositAmount() external view returns (uint256); - ```*/ +```solidity +function minDepositAmount() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct minDepositAmountCall {} @@ -2816,23 +3142,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: minDepositAmountCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for minDepositAmountCall { + impl ::core::convert::From> + for minDepositAmountCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -2842,26 +3172,32 @@ pub mod FeeContract { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: minDepositAmountReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for minDepositAmountReturn { + impl ::core::convert::From> + for minDepositAmountReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -2870,10 +3206,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for minDepositAmountCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = minDepositAmountReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "minDepositAmount()"; const SELECTOR: [u8; 4] = [100u8, 80u8, 6u8, 202u8]; #[inline] @@ -2891,17 +3231,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `owner()` and selector `0x8da5cb5b`. - ```solidity - function owner() external view returns (address); - ```*/ +```solidity +function owner() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ownerCall {} @@ -2927,11 +3267,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2956,11 +3298,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2981,10 +3325,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for ownerCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = ownerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "owner()"; const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; #[inline] @@ -3002,17 +3350,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `proxiableUUID()` and selector `0x52d1902d`. - ```solidity - function proxiableUUID() external view returns (bytes32); - ```*/ +```solidity +function proxiableUUID() external view returns (bytes32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct proxiableUUIDCall {} @@ -3038,11 +3386,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3067,11 +3417,13 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3092,10 +3444,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for proxiableUUIDCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = proxiableUUIDReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "proxiableUUID()"; const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8]; #[inline] @@ -3113,17 +3469,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `renounceOwnership()` and selector `0x715018a6`. - ```solidity - function renounceOwnership() external; - ```*/ +```solidity +function renounceOwnership() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct renounceOwnershipCall {} @@ -3146,23 +3502,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipCall { + impl ::core::convert::From> + for renounceOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3175,23 +3535,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipReturn { + impl ::core::convert::From> + for renounceOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3200,10 +3564,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for renounceOwnershipCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = renounceOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "renounceOwnership()"; const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; #[inline] @@ -3221,17 +3589,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. - ```solidity - function transferOwnership(address newOwner) external; - ```*/ +```solidity +function transferOwnership(address newOwner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct transferOwnershipCall { @@ -3257,23 +3625,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipCall) -> Self { (value.newOwner,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipCall { + impl ::core::convert::From> + for transferOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newOwner: tuple.0 } } @@ -3286,23 +3658,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipReturn { + impl ::core::convert::From> + for transferOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3311,10 +3687,14 @@ pub mod FeeContract { #[automatically_derived] impl alloy_sol_types::SolCall for transferOwnershipCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = transferOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "transferOwnership(address)"; const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; #[inline] @@ -3336,17 +3716,17 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`. - ```solidity - function upgradeToAndCall(address newImplementation, bytes memory data) external payable; - ```*/ +```solidity +function upgradeToAndCall(address newImplementation, bytes memory data) external payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct upgradeToAndCallCall { @@ -3380,23 +3760,27 @@ pub mod FeeContract { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallCall) -> Self { (value.newImplementation, value.data) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallCall { + impl ::core::convert::From> + for upgradeToAndCallCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newImplementation: tuple.0, @@ -3412,23 +3796,27 @@ pub mod FeeContract { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallReturn { + impl ::core::convert::From> + for upgradeToAndCallReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3440,10 +3828,14 @@ pub mod FeeContract { alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Bytes, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = upgradeToAndCallReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)"; const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8]; #[inline] @@ -3468,10 +3860,10 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -3535,28 +3927,34 @@ pub mod FeeContract { match self { Self::UPGRADE_INTERFACE_VERSION(_) => { ::SELECTOR - }, + } Self::balances(_) => ::SELECTOR, Self::deposit(_) => ::SELECTOR, - Self::getVersion(_) => ::SELECTOR, - Self::initialize(_) => ::SELECTOR, + Self::getVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } Self::maxDepositAmount(_) => { ::SELECTOR - }, + } Self::minDepositAmount(_) => { ::SELECTOR - }, + } Self::owner(_) => ::SELECTOR, - Self::proxiableUUID(_) => ::SELECTOR, + Self::proxiableUUID(_) => { + ::SELECTOR + } Self::renounceOwnership(_) => { ::SELECTOR - }, + } Self::transferOwnership(_) => { ::SELECTOR - }, + } Self::upgradeToAndCall(_) => { ::SELECTOR - }, + } } } #[inline] @@ -3574,157 +3972,174 @@ pub mod FeeContract { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result] = - &[ - { - fn getVersion( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + static DECODE_SHIMS: &[fn( + &[u8], + bool, + ) -> alloy_sol_types::Result] = &[ + { + fn getVersion( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::getVersion) - } - getVersion - }, - { - fn balances( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + getVersion + }, + { + fn balances( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::balances) - } - balances - }, - { - fn upgradeToAndCall( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + balances + }, + { + fn upgradeToAndCall( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::upgradeToAndCall) - } - upgradeToAndCall - }, - { - fn proxiableUUID( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + upgradeToAndCall + }, + { + fn proxiableUUID( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::proxiableUUID) - } - proxiableUUID - }, - { - fn minDepositAmount( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + proxiableUUID + }, + { + fn minDepositAmount( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::minDepositAmount) - } - minDepositAmount - }, - { - fn renounceOwnership( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + minDepositAmount + }, + { + fn renounceOwnership( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn owner( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) - .map(FeeContractCalls::owner) - } - owner - }, - { - fn maxDepositAmount( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + renounceOwnership + }, + { + fn owner( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, + ) + .map(FeeContractCalls::owner) + } + owner + }, + { + fn maxDepositAmount( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::maxDepositAmount) - } - maxDepositAmount - }, - { - fn UPGRADE_INTERFACE_VERSION( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + maxDepositAmount + }, + { + fn UPGRADE_INTERFACE_VERSION( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(FeeContractCalls::UPGRADE_INTERFACE_VERSION) - } - UPGRADE_INTERFACE_VERSION - }, - { - fn initialize( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + UPGRADE_INTERFACE_VERSION + }, + { + fn initialize( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::initialize) - } - initialize - }, - { - fn transferOwnership( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + initialize + }, + { + fn transferOwnership( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::transferOwnership) - } - transferOwnership - }, - { - fn deposit( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + transferOwnership + }, + { + fn deposit( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(FeeContractCalls::deposit) - } - deposit - }, - ]; + } + deposit + }, + ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3735,40 +4150,52 @@ pub mod FeeContract { ::abi_encoded_size( inner, ) - }, + } Self::balances(inner) => { ::abi_encoded_size(inner) - }, + } Self::deposit(inner) => { ::abi_encoded_size(inner) - }, + } Self::getVersion(inner) => { ::abi_encoded_size(inner) - }, + } Self::initialize(inner) => { ::abi_encoded_size(inner) - }, + } Self::maxDepositAmount(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::minDepositAmount(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::owner(inner) => { ::abi_encoded_size(inner) - }, + } Self::proxiableUUID(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::renounceOwnership(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::transferOwnership(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::upgradeToAndCall(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } } } #[inline] @@ -3776,42 +4203,70 @@ pub mod FeeContract { match self { Self::UPGRADE_INTERFACE_VERSION(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::balances(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::deposit(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::getVersion(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::initialize(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::maxDepositAmount(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::minDepositAmount(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::owner(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::proxiableUUID(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::renounceOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::transferOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::upgradeToAndCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -3884,49 +4339,49 @@ pub mod FeeContract { match self { Self::AddressEmptyCode(_) => { ::SELECTOR - }, + } Self::DepositTooLarge(_) => { ::SELECTOR - }, + } Self::DepositTooSmall(_) => { ::SELECTOR - }, + } Self::ERC1967InvalidImplementation(_) => { ::SELECTOR - }, + } Self::ERC1967NonPayable(_) => { ::SELECTOR - }, + } Self::FailedInnerCall(_) => { ::SELECTOR - }, + } Self::FunctionDoesNotExist(_) => { ::SELECTOR - }, + } Self::InvalidInitialization(_) => { ::SELECTOR - }, + } Self::InvalidUserAddress(_) => { ::SELECTOR - }, + } Self::NoFunctionCalled(_) => { ::SELECTOR - }, + } Self::NotInitializing(_) => { ::SELECTOR - }, + } Self::OwnableInvalidOwner(_) => { ::SELECTOR - }, + } Self::OwnableUnauthorizedAccount(_) => { ::SELECTOR - }, + } Self::UUPSUnauthorizedCallContext(_) => { ::SELECTOR - }, + } Self::UUPSUnsupportedProxiableUUID(_) => { ::SELECTOR - }, + } } } #[inline] @@ -3947,17 +4402,17 @@ pub mod FeeContract { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn OwnableUnauthorizedAccount( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::OwnableUnauthorizedAccount) + data, + validate, + ) + .map(FeeContractErrors::OwnableUnauthorizedAccount) } OwnableUnauthorizedAccount }, @@ -3967,9 +4422,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::FailedInnerCall) + data, + validate, + ) + .map(FeeContractErrors::FailedInnerCall) } FailedInnerCall }, @@ -3979,9 +4435,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::OwnableInvalidOwner) + data, + validate, + ) + .map(FeeContractErrors::OwnableInvalidOwner) } OwnableInvalidOwner }, @@ -3991,9 +4448,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::ERC1967InvalidImplementation) + data, + validate, + ) + .map(FeeContractErrors::ERC1967InvalidImplementation) } ERC1967InvalidImplementation }, @@ -4003,9 +4461,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::DepositTooSmall) + data, + validate, + ) + .map(FeeContractErrors::DepositTooSmall) } DepositTooSmall }, @@ -4015,9 +4474,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::InvalidUserAddress) + data, + validate, + ) + .map(FeeContractErrors::InvalidUserAddress) } InvalidUserAddress }, @@ -4027,9 +4487,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::AddressEmptyCode) + data, + validate, + ) + .map(FeeContractErrors::AddressEmptyCode) } AddressEmptyCode }, @@ -4039,9 +4500,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::FunctionDoesNotExist) + data, + validate, + ) + .map(FeeContractErrors::FunctionDoesNotExist) } FunctionDoesNotExist }, @@ -4051,9 +4513,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::UUPSUnsupportedProxiableUUID) + data, + validate, + ) + .map(FeeContractErrors::UUPSUnsupportedProxiableUUID) } UUPSUnsupportedProxiableUUID }, @@ -4063,9 +4526,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::ERC1967NonPayable) + data, + validate, + ) + .map(FeeContractErrors::ERC1967NonPayable) } ERC1967NonPayable }, @@ -4075,9 +4539,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::NoFunctionCalled) + data, + validate, + ) + .map(FeeContractErrors::NoFunctionCalled) } NoFunctionCalled }, @@ -4087,9 +4552,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::DepositTooLarge) + data, + validate, + ) + .map(FeeContractErrors::DepositTooLarge) } DepositTooLarge }, @@ -4099,9 +4565,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::NotInitializing) + data, + validate, + ) + .map(FeeContractErrors::NotInitializing) } NotInitializing }, @@ -4111,9 +4578,10 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::UUPSUnauthorizedCallContext) + data, + validate, + ) + .map(FeeContractErrors::UUPSUnauthorizedCallContext) } UUPSUnauthorizedCallContext }, @@ -4123,18 +4591,21 @@ pub mod FeeContract { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(FeeContractErrors::InvalidInitialization) + data, + validate, + ) + .map(FeeContractErrors::InvalidInitialization) } InvalidInitialization }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -4142,116 +4613,175 @@ pub mod FeeContract { fn abi_encoded_size(&self) -> usize { match self { Self::AddressEmptyCode(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::DepositTooLarge(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::DepositTooSmall(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::ERC1967InvalidImplementation(inner) => { ::abi_encoded_size( inner, ) - }, + } Self::ERC1967NonPayable(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::FailedInnerCall(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::FunctionDoesNotExist(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::InvalidInitialization(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::InvalidUserAddress(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::NoFunctionCalled(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::NotInitializing(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::OwnableInvalidOwner(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::OwnableUnauthorizedAccount(inner) => { ::abi_encoded_size( inner, ) - }, + } Self::UUPSUnauthorizedCallContext(inner) => { ::abi_encoded_size( inner, ) - }, + } Self::UUPSUnsupportedProxiableUUID(inner) => { ::abi_encoded_size( inner, ) - }, + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::AddressEmptyCode(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::DepositTooLarge(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::DepositTooSmall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::ERC1967InvalidImplementation(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::ERC1967NonPayable(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::FailedInnerCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::FunctionDoesNotExist(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::InvalidInitialization(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::InvalidUserAddress(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::NoFunctionCalled(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::NotInitializing(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::OwnableInvalidOwner(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::OwnableUnauthorizedAccount(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::UUPSUnauthorizedCallContext(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::UUPSUnsupportedProxiableUUID(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } } } } @@ -4280,34 +4810,208 @@ pub mod FeeContract { /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 32usize]] = &[ [ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8, - 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8, - 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, ], [ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8, - 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8, - 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, ], [ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, ], [ - 221u8, 151u8, 13u8, 217u8, 181u8, 191u8, 231u8, 7u8, 146u8, 33u8, 85u8, 176u8, - 88u8, 164u8, 7u8, 101u8, 92u8, 177u8, 130u8, 136u8, 184u8, 7u8, 226u8, 33u8, 100u8, - 66u8, 188u8, 168u8, 173u8, 131u8, 214u8, 181u8, + 221u8, + 151u8, + 13u8, + 217u8, + 181u8, + 191u8, + 231u8, + 7u8, + 146u8, + 33u8, + 85u8, + 176u8, + 88u8, + 164u8, + 7u8, + 101u8, + 92u8, + 177u8, + 130u8, + 136u8, + 184u8, + 7u8, + 226u8, + 33u8, + 100u8, + 66u8, + 188u8, + 168u8, + 173u8, + 131u8, + 214u8, + 181u8, ], [ - 225u8, 255u8, 252u8, 196u8, 146u8, 61u8, 4u8, 181u8, 89u8, 244u8, 210u8, 154u8, - 139u8, 252u8, 108u8, 218u8, 4u8, 235u8, 91u8, 13u8, 60u8, 70u8, 7u8, 81u8, 194u8, - 64u8, 44u8, 92u8, 92u8, 201u8, 16u8, 156u8, + 225u8, + 255u8, + 252u8, + 196u8, + 146u8, + 61u8, + 4u8, + 181u8, + 89u8, + 244u8, + 210u8, + 154u8, + 139u8, + 252u8, + 108u8, + 218u8, + 4u8, + 235u8, + 91u8, + 13u8, + 60u8, + 70u8, + 7u8, + 81u8, + 194u8, + 64u8, + 44u8, + 92u8, + 92u8, + 201u8, + 16u8, + 156u8, ], [ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8, - 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, ], ]; } @@ -4322,42 +5026,66 @@ pub mod FeeContract { ) -> alloy_sol_types::Result { match topics.first().copied() { Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Deposit) - }, + } Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::Initialized) - }, + topics, + data, + validate, + ) + .map(Self::Initialized) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Log) - }, - Some(::SIGNATURE_HASH) => { + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::OwnershipTransferred) - }, + topics, + data, + validate, + ) + .map(Self::OwnershipTransferred) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgrade) - }, + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgraded) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -4365,39 +5093,53 @@ pub mod FeeContract { impl alloy_sol_types::private::IntoLogData for FeeContractEvents { fn to_log_data(&self) -> alloy_sol_types::private::LogData { match self { - Self::Deposit(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + Self::Deposit(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::Log(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::Log(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), - Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { - Self::Deposit(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + Self::Deposit(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, - Self::Log(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + } + Self::Log(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::Upgraded(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`FeeContract`](self) contract instance. - See the [wrapper's documentation](`FeeContractInstance`) for more details.*/ +See the [wrapper's documentation](`FeeContractInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -4411,9 +5153,9 @@ pub mod FeeContract { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -4421,36 +5163,35 @@ pub mod FeeContract { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { FeeContractInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { FeeContractInstance::::deploy_builder(provider) } /**A [`FeeContract`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`FeeContract`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`FeeContract`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct FeeContractInstance { address: alloy_sol_types::private::Address, @@ -4461,24 +5202,24 @@ pub mod FeeContract { impl ::core::fmt::Debug for FeeContractInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("FeeContractInstance") - .field(&self.address) - .finish() + f.debug_tuple("FeeContractInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FeeContractInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > FeeContractInstance { /**Creates a new wrapper around an on-chain [`FeeContract`](self) contract instance. - See the [wrapper's documentation](`FeeContractInstance`) for more details.*/ +See the [wrapper's documentation](`FeeContractInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -4487,20 +5228,22 @@ pub mod FeeContract { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] - pub async fn deploy(provider: P) -> alloy_contract::Result> { + pub async fn deploy( + provider: P, + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -4543,11 +5286,10 @@ pub mod FeeContract { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FeeContractInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > FeeContractInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -4579,7 +5321,9 @@ pub mod FeeContract { self.call_builder(&depositCall { user }) } ///Creates a new call builder for the [`getVersion`] function. - pub fn getVersion(&self) -> alloy_contract::SolCallBuilder { + pub fn getVersion( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&getVersionCall {}) } ///Creates a new call builder for the [`initialize`] function. @@ -4606,7 +5350,9 @@ pub mod FeeContract { self.call_builder(&ownerCall {}) } ///Creates a new call builder for the [`proxiableUUID`] function. - pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder { + pub fn proxiableUUID( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&proxiableUUIDCall {}) } ///Creates a new call builder for the [`renounceOwnership`] function. @@ -4628,20 +5374,21 @@ pub mod FeeContract { newImplementation: alloy::sol_types::private::Address, data: alloy::sol_types::private::Bytes, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&upgradeToAndCallCall { - newImplementation, - data, - }) + self.call_builder( + &upgradeToAndCallCall { + newImplementation, + data, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > FeeContractInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > FeeContractInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -4656,7 +5403,9 @@ pub mod FeeContract { self.event_filter::() } ///Creates a new event filter for the [`Initialized`] event. - pub fn Initialized_filter(&self) -> alloy_contract::Event { + pub fn Initialized_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } ///Creates a new event filter for the [`Log`] event. diff --git a/contract-bindings-alloy/src/iplonkverifier.rs b/contract-bindings-alloy/src/iplonkverifier.rs index 6d334f24a6..046d214367 100644 --- a/contract-bindings-alloy/src/iplonkverifier.rs +++ b/contract-bindings-alloy/src/iplonkverifier.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -1258,9 +1315,8 @@ interface IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -1282,8 +1338,8 @@ pub mod IPlonkVerifier { b"", ); /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -1396,11 +1452,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1479,23 +1537,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -1506,50 +1586,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1563,111 +1657,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.wire3, + ) + .0, + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) + .0, + ::eip712_data_word( + &self.split1, + ) + .0, + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) + .0, + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1750,7 +1946,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1796,7 +1994,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1844,16 +2043,23 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } - ```*/ +struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct VerifyingKey { @@ -1962,11 +2168,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2075,50 +2283,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for VerifyingKey { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -2132,64 +2354,154 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(18); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] @@ -2368,7 +2680,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -2402,43 +2716,56 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.q1, out, + &rust.q1, + out, ); ::encode_topic_preimage( - &rust.q2, out, + &rust.q2, + out, ); ::encode_topic_preimage( - &rust.q3, out, + &rust.q3, + out, ); ::encode_topic_preimage( - &rust.q4, out, + &rust.q4, + out, ); ::encode_topic_preimage( - &rust.qM12, out, + &rust.qM12, + out, ); ::encode_topic_preimage( - &rust.qM34, out, + &rust.qM34, + out, ); ::encode_topic_preimage( - &rust.qO, out, + &rust.qO, + out, ); ::encode_topic_preimage( - &rust.qC, out, + &rust.qC, + out, ); ::encode_topic_preimage( - &rust.qH1, out, + &rust.qH1, + out, ); ::encode_topic_preimage( - &rust.qH2, out, + &rust.qH2, + out, ); ::encode_topic_preimage( - &rust.qH3, out, + &rust.qH3, + out, ); ::encode_topic_preimage( - &rust.qH4, out, + &rust.qH4, + out, ); ::encode_topic_preimage( - &rust.qEcc, out, + &rust.qEcc, + out, ); alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**Function with signature `verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[8],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x64e4c59e`. - ```solidity - function verify(VerifyingKey memory verifyingKey, uint256[8] memory publicInput, PlonkProof memory proof) external view returns (bool); - ```*/ +```solidity +function verify(VerifyingKey memory verifyingKey, uint256[8] memory publicInput, PlonkProof memory proof) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct verifyCall { @@ -2508,11 +2842,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2541,11 +2877,13 @@ pub mod IPlonkVerifier { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2573,10 +2911,14 @@ pub mod IPlonkVerifier { >, PlonkProof, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = verifyReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[8],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [100u8, 228u8, 197u8, 158u8]; #[inline] @@ -2588,7 +2930,9 @@ pub mod IPlonkVerifier { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize(&self.verifyingKey), + ::tokenize( + &self.verifyingKey, + ), , 8usize, @@ -2601,10 +2945,10 @@ pub mod IPlonkVerifier { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -2652,22 +2996,28 @@ pub mod IPlonkVerifier { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[{ - fn verify( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) - .map(IPlonkVerifierCalls::verify) - } - verify - }]; + ) -> alloy_sol_types::Result] = &[ + { + fn verify( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, + ) + .map(IPlonkVerifierCalls::verify) + } + verify + }, + ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -2676,7 +3026,7 @@ pub mod IPlonkVerifier { match self { Self::verify(inner) => { ::abi_encoded_size(inner) - }, + } } } #[inline] @@ -2684,14 +3034,14 @@ pub mod IPlonkVerifier { match self { Self::verify(inner) => { ::abi_encode_raw(inner, out) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -2705,9 +3055,9 @@ pub mod IPlonkVerifier { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -2715,36 +3065,35 @@ pub mod IPlonkVerifier { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { IPlonkVerifierInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { IPlonkVerifierInstance::::deploy_builder(provider) } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -2755,24 +3104,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -2781,9 +3130,9 @@ pub mod IPlonkVerifier { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -2793,10 +3142,10 @@ pub mod IPlonkVerifier { Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -2839,11 +3188,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -2861,21 +3209,22 @@ pub mod IPlonkVerifier { publicInput: [alloy::sol_types::private::primitives::aliases::U256; 8usize], proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&verifyCall { - verifyingKey, - publicInput, - proof, - }) + self.call_builder( + &verifyCall { + verifyingKey, + publicInput, + proof, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. diff --git a/contract-bindings-alloy/src/lightclient.rs b/contract-bindings-alloy/src/lightclient.rs index c5f11bd7cc..c677fedaba 100644 --- a/contract-bindings-alloy/src/lightclient.rs +++ b/contract-bindings-alloy/src/lightclient.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -563,12 +620,11 @@ library IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -681,11 +737,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -764,23 +822,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -791,50 +871,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -848,111 +942,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) + .0, + ::eip712_data_word( + &self.wire3, + ) + .0, + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) + .0, + ::eip712_data_word( + &self.split1, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) + .0, + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1035,7 +1231,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1081,7 +1279,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1129,17 +1328,24 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1153,15 +1359,15 @@ pub mod IPlonkVerifier { } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -1172,24 +1378,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1231,11 +1437,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -1250,11 +1455,10 @@ pub mod IPlonkVerifier { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -2370,9 +2574,8 @@ interface LightClient { clippy::empty_structs_with_brackets )] pub mod LightClient { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -2394,8 +2597,8 @@ pub mod LightClient { b"`\x80`@R`\x046\x10a\x01GW_5`\xE0\x1C\x80c\x82nA\xFC\x11a\0\xB3W\x80c\xAD<\xB1\xCC\x11a\0mW\x80c\xAD<\xB1\xCC\x14a\x04jW\x80c\xC2;\x9E\x9E\x14a\x04\xA7W\x80c\xD2M\x93=\x14a\x04\xDFW\x80c\xE003\x01\x14a\x05\x0EW\x80c\xF2\xFD\xE3\x8B\x14a\x05-W\x80c\xF9\xE5\r\x19\x14a\x05LW_\x80\xFD[\x80c\x82nA\xFC\x14a\x034W\x80c\x85\x84\xD2?\x14a\x03_W\x80c\x8D\xA5\xCB[\x14a\x03\x9BW\x80c\x96\xC1\xCAa\x14a\x03\xD7W\x80c\x9B\xAA<\xC9\x14a\x03\xF6W\x80c\x9F\xDBT\xA7\x14a\x04\x15W_\x80\xFD[\x80c7\x8E\xC2;\x11a\x01\x04W\x80c7\x8E\xC2;\x14a\x02\x88W\x80cBm1\x94\x14a\x02\xA4W\x80cO\x1E\xF2\x86\x14a\x02\xE5W\x80cR\xD1\x90-\x14a\x02\xF8W\x80ci\xCCj\x04\x14a\x03\x0CW\x80cqP\x18\xA6\x14a\x03 W_\x80\xFD[\x80c\x01?\xA5\xFC\x14a\x01KW\x80c\x02\xB5\x92\xF3\x14a\x01lW\x80c\r\x8En,\x14a\x01\xC9W\x80c c\xD4\xF7\x14a\x01\xF4W\x80c/y\x88\x9D\x14a\x02\x13W\x80c1=\xF7\xB1\x14a\x02QW[_\x80\xFD[4\x80\x15a\x01VW_\x80\xFD[Pa\x01ja\x01e6`\x04a\x1F\x1DV[a\x05`V[\0[4\x80\x15a\x01wW_\x80\xFD[Pa\x01\x8Ba\x01\x866`\x04a\x1F6V[a\x06\x13V[`@Qa\x01\xC0\x94\x93\x92\x91\x90`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x84\x01R\x92\x16`@\x82\x01R``\x81\x01\x91\x90\x91R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xD4W_\x80\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01a\x01\xC0V[4\x80\x15a\x01\xFFW_\x80\xFD[Pa\x01ja\x02\x0E6`\x04a \x81V[a\x06\\V[4\x80\x15a\x02\x1EW_\x80\xFD[P`\x08Ta\x029\x90`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x81V[`@Q`\x01`\x01`@\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\\W_\x80\xFD[P`\x08Ta\x02p\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\x93W_\x80\xFD[PC[`@Q\x90\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\xAFW_\x80\xFD[P_T`\x01T`\x02T`\x03Ta\x02\xC5\x93\x92\x91\x90\x84V[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R``\x82\x01R`\x80\x01a\x01\xC0V[a\x01ja\x02\xF36`\x04a\"2V[a\x07\xB6V[4\x80\x15a\x03\x03W_\x80\xFD[Pa\x02\x96a\x07\xD5V[4\x80\x15a\x03\x17W_\x80\xFD[Pa\x01ja\x07\xF0V[4\x80\x15a\x03+W_\x80\xFD[Pa\x01ja\x08^V[4\x80\x15a\x03?W_\x80\xFD[P`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15\x15[`@Q\x90\x15\x15\x81R` \x01a\x01\xC0V[4\x80\x15a\x03jW_\x80\xFD[Pa\x03~a\x03y6`\x04a\x1F6V[a\x08oV[`@\x80Q\x92\x83R`\x01`\x01`@\x1B\x03\x90\x91\x16` \x83\x01R\x01a\x01\xC0V[4\x80\x15a\x03\xA6W_\x80\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16a\x02pV[4\x80\x15a\x03\xE2W_\x80\xFD[Pa\x01ja\x03\xF16`\x04a\"\xE4V[a\t\x9AV[4\x80\x15a\x04\x01W_\x80\xFD[Pa\x01ja\x04\x106`\x04a\"\xFDV[a\n#V[4\x80\x15a\x04 W_\x80\xFD[P`\x06T`\x07Ta\x04D\x91`\x01`\x01`@\x1B\x03\x80\x82\x16\x92`\x01`@\x1B\x90\x92\x04\x16\x90\x83V[`@\x80Q`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x93\x90\x92\x16` \x84\x01R\x90\x82\x01R``\x01a\x01\xC0V[4\x80\x15a\x04uW_\x80\xFD[Pa\x04\x9A`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\x01\xC0\x91\x90a#\xC8V[4\x80\x15a\x04\xB2W_\x80\xFD[P`\x08Ta\x04\xCA\x90`\x01`\xA0\x1B\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x04\xEAW_\x80\xFD[P`\x04T`\x05Ta\x04D\x91`\x01`\x01`@\x1B\x03\x80\x82\x16\x92`\x01`@\x1B\x90\x92\x04\x16\x90\x83V[4\x80\x15a\x05\x19W_\x80\xFD[Pa\x03Oa\x05(6`\x04a#\xFAV[a\x0BEV[4\x80\x15a\x058W_\x80\xFD[Pa\x01ja\x05G6`\x04a\x1F\x1DV[a\x0C\x9FV[4\x80\x15a\x05WW_\x80\xFD[P`\tTa\x02\x96V[a\x05ha\x0C\xE1V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\x8FW`@Qc\xE6\xC4${`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x82\x16\x03a\x05\xBEW`@Qc\xA8c\xAE\xC9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x80\x17\xBB\x88\x7F\xDF\x8F\xCAC\x14\xA9\xD4\x0Fns\xB3\xB8\x10\x02\xD6~\\\xFA\x85\xD8\x81s\xAFj\xA4`r\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[`\t\x81\x81T\x81\x10a\x06\"W_\x80\xFD[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01\x80T`\x01\x90\x91\x01T`\x01`\x01`@\x1B\x03\x80\x83\x16\x93P`\x01`@\x1B\x83\x04\x81\x16\x92`\x01`\x80\x1B\x90\x04\x16\x90\x84V[`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x80\x15a\x06\x81WP`\x08T`\x01`\x01`\xA0\x1B\x03\x163\x14\x15[\x15a\x06\x9FW`@Qc\x01GL\x8F`\xE7\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x06T\x82Q`\x01`\x01`@\x1B\x03\x91\x82\x16\x91\x16\x11\x15\x80a\x06\xD8WP`\x06T` \x83\x01Q`\x01`\x01`@\x1B\x03`\x01`@\x1B\x90\x92\x04\x82\x16\x91\x16\x11\x15[\x15a\x06\xF6W`@Qc\x05\x1CF\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\x03\x82`@\x01Qa\r#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90`\x01`\x01`@\x1B\x03\x16_\x81\x15\x80\x15a\ngWP\x82[\x90P_\x82`\x01`\x01`@\x1B\x03\x16`\x01\x14\x80\x15a\n\x82WP0;\x15[\x90P\x81\x15\x80\x15a\n\x90WP\x80\x15[\x15a\n\xAEW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\n\xD8W\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\n\xE1\x86a\x12\xE8V[a\n\xE9a\x12\xF9V[a\n\xF4\x89\x89\x89a\x13\x01V[\x83\x15a\x0B:W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPV[`\tT_\x90C\x84\x11\x80a\x0BVWP\x80\x15[\x80a\x0B\xA0WP`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0B\x84Wa\x0B\x84a$AV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x84\x10[\x15a\x0B\xBEW`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80a\x0B\xCC`\x01\x85a$.V[\x90P[\x81a\x0ChW`\x08T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x81\x10a\x0ChW\x86`\t\x82\x81T\x81\x10a\x0C\x01Wa\x0C\x01a$AV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x11a\x0CVW`\x01\x91P`\t\x81\x81T\x81\x10a\x0C6Wa\x0C6a$AV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x92Pa\x0ChV[\x80a\x0C`\x81a$UV[\x91PPa\x0B\xCFV[\x81a\x0C\x86W`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85a\x0C\x91\x84\x89a$.V[\x11\x94PPPPP[\x92\x91PPV[a\x0C\xA7a\x0C\xE1V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0C\xD5W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x0C\xDE\x81a\x12xV[PV[3a\r\x13\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x08\\W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x0C\xCCV[\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x81\x10\x80a\x07\xD1W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FBn254: invalid scalar field\0\0\0\0\0`D\x82\x01R`d\x01a\x0C\xCCV[_a\r\xB5a\x14-V[\x90Pa\r\xBFa\x1C~V[\x83Q`\x01`\x01`@\x1B\x03\x90\x81\x16\x82R` \x85\x01Q\x16\x81`\x01` \x02\x01R`@\x84\x81\x01Q\x82\x82\x01R`\x01T``\x83\x01R`\x02T`\x80\x83\x01R`\x03T`\xA0\x83\x01R_T`\xC0\x83\x01RQc\xCESzw`\xE0\x1B\x81Rs_\xBD\xB21Vx\xAF\xEC\xB3g\xF02\xD9?d/d\x18\n\xA3\x90c\xCESzw\x90a\x0E>\x90\x85\x90\x85\x90\x88\x90`\x04\x01a&pV[` `@Q\x80\x83\x03\x81\x86Z\xF4\x15\x80\x15a\x0EYW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E}\x91\x90a(\x9EV[a\x0E\x9AW`@Qc\t\xBD\xE39`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\tT\x15\x80\x15\x90a\x0F\x15WP`\x08T`\t\x80T`\x01`\xA0\x1B\x83\x04c\xFF\xFF\xFF\xFF\x16\x92`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0E\xE0Wa\x0E\xE0a$AV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01Ta\x0F\n\x90`\x01`@\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x84a(\xBDV[`\x01`\x01`@\x1B\x03\x16\x11[\x15a\x0F\xA8W`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0FBWa\x0FBa$AV[_\x91\x82R` \x82 `\x02\x90\x91\x02\x01\x80T`\x01`\x01`\xC0\x1B\x03\x19\x16\x81U`\x01\x01U`\x08\x80T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90`\x18a\x0F\x82\x83a(\xE4V[\x91\x90a\x01\0\n\x81T\x81`\x01`\x01`@\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`@\x1B\x03\x16\x02\x17\x90UPP[`@\x80Q`\x80\x81\x01\x82R`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x80\x85\x01\x91\x82R\x83\x01Q\x85\x16\x84\x83\x01\x90\x81R\x92\x90\x91\x01Q``\x84\x01\x90\x81R`\t\x80T`\x01\x81\x01\x82U_\x91\x90\x91R\x93Q`\x02\x90\x94\x02\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xAF\x81\x01\x80T\x93Q\x94Q\x87\x16`\x01`\x80\x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x80\x1B\x19\x95\x88\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x95\x16\x96\x90\x97\x16\x95\x90\x95\x17\x92\x90\x92\x17\x92\x90\x92\x16\x93\x90\x93\x17\x90\x91UQ\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xB0\x90\x91\x01UV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x11\x0FWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16a\x11\x03_\x80Q` a)<\x839\x81Q\x91RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x08\\W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x115a\x0C\xE1V[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01a\x06\x08V[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x11\xC8WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x11\xC5\x91\x81\x01\x90a)\tV[`\x01[a\x11\xF0W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[_\x80Q` a)<\x839\x81Q\x91R\x81\x14a\x12 W`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x0C\xCCV[a\x12*\x83\x83a\x1A\\V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x08\\W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\x12\xF0a\x1A\xB1V[a\x0C\xDE\x81a\x1A\xFAV[a\x08\\a\x1A\xB1V[\x82Q`\x01`\x01`@\x1B\x03\x16\x15\x15\x80a\x13%WP` \x83\x01Q`\x01`\x01`@\x1B\x03\x16\x15\x15[\x80a\x132WP` \x82\x01Q\x15[\x80a\x13?WP`@\x82\x01Q\x15[\x80a\x13LWP``\x82\x01Q\x15[\x80a\x13VWP\x81Q\x15[\x80a\x13hWPa\x0E\x10\x81c\xFF\xFF\xFF\xFF\x16\x10[\x80a\x13|WPc\x01\xE13\x80\x81c\xFF\xFF\xFF\xFF\x16\x11[\x15a\x13\x9AW`@QcP\xDD\x03\xF7`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82Q`\x04\x80T` \x80\x87\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x93\x84\x16\x91\x90\x95\x16\x90\x81\x17\x85\x17\x90\x93U`@\x96\x87\x01Q`\x05\x81\x90U\x86Q_U\x90\x86\x01Q`\x01U\x95\x85\x01Q`\x02U``\x90\x94\x01Q`\x03U`\x06\x80T\x90\x94\x16\x17\x17\x90\x91U`\x07\x91\x90\x91U`\x08\x80Tc\xFF\xFF\xFF\xFF\x90\x92\x16`\x01`\xA0\x1B\x02c\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[a\x145a\x1C\x9CV[b\x10\0\0\x81R`\x07` \x82\x01R\x7F#x=\x0E\x97w\xB7\xAFe\xFB\xF8I\xDA~\xDBu\xE7K\x1E\xAFP>\x02]\x7F/\x7F\x80\x99\x1B\xEF\xA2`@\x82\x01QR\x7F*N/\xE8\xAD\xFAS\xF4hRU\x82\xD5\x18LLp\xBB\xDB\x94l!\xF2\x16A\x8A\x98yp^T\xA7` `@\x83\x01Q\x01R\x7F\x06$\xB2\xC1\xE7\x7F$\xAF\xCE\xAF9E\x17C\xB9\xFA\x80\xD5\x85?\xCA{\xA0\x03\x89\xC6ue\x07t\0\x9B``\x82\x01QR\x7F%\rw\x19\xE9L\xA2\xDF\0\xDF\xE3'\x93\x8FZ\x8DM\x83wy\xB9\x987\xCAwzS\xD3\x91'\xB1y` ``\x83\x01Q\x01R\x7F\r\xC0\x95\x15\x15.\xAE\xA6m\r\xB2\xF5q\xCC\x99^6\x9D&\xFEds\x94\xF1\r\xB59\x8C\x91u\x19\xDC`\x80\x82\x01QR\x7F\x12s\x14Ml\xEC,Jh\xB2J\x14\x93y\xC0\xF5Y+\xB7\xFB\xDD\xBE2\xFA\x17\x19\x19\x95\x0C\xA4\x04\xCB` `\x80\x83\x01Q\x01R\x7F\x11\x95!\xBBh\xCA\xEC!n/\x05\xEE\xB4f\xFB:\xBF\xE1\xF3\x9B\xAF\x7F\xE7\xCB9.\xA0W\xB6\xA2\xD9\xBF`\xA0\x82\x01QR\x7F-R\xAD\xEA\xBA\x80E\xE5:\xB5&\xFE\x99\x82\xD0\xEAE-\xEFk>\xA0%='\xA1\x9E\xF3\xB4n\x84(` `\xA0\x83\x01Q\x01R\x7F\x16\xC3\xB5\xB2\x17\xD3\x02\x97Z\x92\r\x137E$\xD7\xA5.JP\xFD\x7F\xB90\x84\"q\xEB\xF4\xA8N\xFD`\xC0\x82\x01QR\x7F \x07\x88\x91k\x90{\x19ir\xBD\xE3\x041\x8E\x88Z%!QK-\xB5\xE4\xA1\x18\x99\xC5\x12\x04\xF0\x89` `\xC0\x83\x01Q\x01R\x7F\x11'X\x1A\xFEu=\xEF\xCA\x9A\xEF\x12\xE73-\xB9\x97\x8A \x0B\x16\x99\xCE8\x88\xC0\xF3\xAE\xA6\x11\x1D\xC3`\xE0\x82\x01QR\x7F\x08\x81\xE1?\0r;\xE1\xA0Hr\xED\x02\xB2\xD0x\xC3\x1E\x80\xFE\xAF'rN&,\xE9|,\xB0\xBB\x1D` `\xE0\x83\x01Q\x01R\x7F\x14\x82\xA3\xA6\xBB\x91\xD6H=\x156\x83\xE2@O/UF\xE0\xE8\x95S\x0F\xDF\x13 \x91I\x84\x06\xE3\xDEa\x01\0\x82\x01QR~\xFAR\xDB=R\xD9\x05\xEA\xD1$\x81\x02\xF3\xA8\nC\xA9\r\x84\0\xC6\x8F`\xA6,T\xC7\x18u\xD8\xDD\xC3UFXd\x0C\xC9U\x01a\x01\xC0\x82\x01QR\x7F$:\x99\xD8\r2\xEBT\x08\xB5\x9D[\x080+\xED\xE0p\xD3\xFB\n\x8E\xFE/\"b\xF8e\xBF\xFBM\r` a\x01\xC0\x83\x01Q\x01R\x7F\x04U\xD22[\xF6&\x9Af\xF0}\x83\x8FU\xF3iG\xA3\xCD\x9B\x87\xED\xD8H\x0B\xCE\xD9\\\xBBE\xCC\x11a\x01\xE0\x82\x01QR\x7F\x0Ff\xD9\x08Zn\xD6\x0B\x83\x81y\x98~$\t\x92\xBF\xF4\xC0Ql\xCFl\xCD\xE4\xA1\xCA\x94\xCE\x8B\x98d` a\x01\xE0\x83\x01Q\x01R\x7F+\xAC\r#\xC8X]\x14\x87\xECa\x1B^\xFF\xC9~XR\xFE\xA4:|\xBA6\xCC\xDD, y1\xF3\x94a\x02\0\x82\x01QR\x7F\x18`\xB5N\x01\xA0j\xEAZ\xDBK\x13\xBF[\xAE\xBA\xB9+sh\x07\xA3\xA8\x9F\xF2\x04\t\x92\xB0n\xE6\xEC` a\x02\0\x83\x01Q\x01R\x7F\x0C\x0B\xFA\x1C/\xC6\xF8\xED\x01#=Qh\xDB\x1E\x1D\xFErU\x04\xF02\xF6i\xF5\n\x92\xAEw\xC7)\x06a\x02 \x82\x01QR\x7F\rt\x1E\x12L}\x10i\xB8\xA4\0\xCB\xCD\xCF\xD9\x01(\xA53\x90\x1A\xD4\xDE\x1E\x03\x7F\xE7)\x84\xDC4\xCF` a\x02 \x83\x01Q\x01R\x7F\x01\xCF\xED0\x08\\\x9E\xFC\xE0Fh W\x94\xAA9\xB1\xA8\xEEY\x124\xB4\xC7z\"\xF8\xC2m\x89\x9E\x05a\x02@\x82\x01QR\x7F*\xB6\x8A\xC8-6\xCE\xDBd}\x14\xA5\xB0\x03^\x8C\x9A\x0B\xE8G\x80\xB7\xBA\xE1\x13:'\xA8\x80\x96n\xD1` a\x02@\x83\x01Q\x01R\x7F\x07.\x1DP\xF8\xB5\xCF\x8DWK8G'dw\xD9[\xBDQ\x165\x10\0\x84\x1Fr\x8D\xA4O@C\xB5a\x02`\x82\x01QR\x7F#\xF8\xEAn\xAC\xD0\x87mW\"\x0FW\xEA\xBA\xCB\xE7j##A\x16cs\x1A%\x1D]\xCA6\xF1\xB5\x9F` a\x02`\x83\x01Q\x01R\x7F\xB0\x83\x88\x93\xEC\x1F#~\x8B\x072;\x07DY\x9FN\x97\xB5\x98\xB3\xB5\x89\xBC\xC2\xBC7\xB8\xD5\xC4\x18\x01a\x02\x80\x82\x01R\x7F\xC1\x83\x93\xC0\xFA0\xFEN\x8B\x03\x8E5z\xD8Q\xEA\xE8\xDE\x91\x07XN\xFF\xE7\xC7\xF1\xF6Q\xB2\x01\x0E&a\x02\xA0\x82\x01R\x90V[a\x1Ae\x82a\x1B\x02V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x1A\xA9Wa\x12*\x82\x82a\x1BeV[a\x07\xD1a\x1B\xD7V[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x08\\W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0C\xA7a\x1A\xB1V[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1B7W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[_\x80Q` a)<\x839\x81Q\x91R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``_\x80\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x1B\x81\x91\x90a) V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1B\xB9W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1B\xBEV[``\x91P[P\x91P\x91Pa\x1B\xCE\x85\x83\x83a\x1B\xF6V[\x95\x94PPPPPV[4\x15a\x08\\W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x1C\x0BWa\x1C\x06\x82a\x1CUV[a\x1CNV[\x81Q\x15\x80\x15a\x1C\"WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x1CKW`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[P\x80[\x93\x92PPPV[\x80Q\x15a\x1CeW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x80`\xE0\x01`@R\x80`\x07\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[`@Q\x80a\x02\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01a\x1C\xCF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1C\xEF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\x0F`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D/`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1DO`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Do`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\x8F`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xAF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xCF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xEF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\x0F`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E/`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1EO`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Eo`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\x8F`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xAF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xCF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xEF`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x90\x91\x01R\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\x18W_\x80\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F-W_\x80\xFD[a\x1CN\x82a\x1F\x02V[_` \x82\x84\x03\x12\x15a\x1FFW_\x80\xFD[P5\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Qa\x02\xE0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x1F\x84Wa\x1F\x84a\x1FMV[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x1F\xB2Wa\x1F\xB2a\x1FMV[`@R\x91\x90PV[\x805`\x01`\x01`@\x1B\x03\x81\x16\x81\x14a\x1F\x18W_\x80\xFD[_``\x82\x84\x03\x12\x15a\x1F\xE0W_\x80\xFD[`@Q``\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a \x02Wa \x02a\x1FMV[`@R\x90P\x80a \x11\x83a\x1F\xBAV[\x81Ra \x1F` \x84\x01a\x1F\xBAV[` \x82\x01R`@\x83\x015`@\x82\x01RP\x92\x91PPV[_`@\x82\x84\x03\x12\x15a EW_\x80\xFD[`@Q`@\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a gWa ga\x1FMV[`@R\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x80\x82\x84\x03a\x04\xE0\x81\x12\x15a \x94W_\x80\xFD[a \x9E\x85\x85a\x1F\xD0V[\x92Pa\x04\x80\x80`_\x19\x83\x01\x12\x15a \xB3W_\x80\xFD[a \xBBa\x1FaV[\x91Pa \xCA\x86``\x87\x01a 5V[\x82Ra \xD9\x86`\xA0\x87\x01a 5V[` \x83\x01Ra \xEB\x86`\xE0\x87\x01a 5V[`@\x83\x01Ra\x01 a \xFF\x87\x82\x88\x01a 5V[``\x84\x01Ra\x01`a!\x13\x88\x82\x89\x01a 5V[`\x80\x85\x01Ra\x01\xA0a!'\x89\x82\x8A\x01a 5V[`\xA0\x86\x01Ra\x01\xE0a!;\x8A\x82\x8B\x01a 5V[`\xC0\x87\x01Ra\x02 a!O\x8B\x82\x8C\x01a 5V[`\xE0\x88\x01Ra\x02`a!c\x8C\x82\x8D\x01a 5V[a\x01\0\x89\x01Ra\x02\xA0a!x\x8D\x82\x8E\x01a 5V[\x87\x8A\x01Ra!\x8A\x8Da\x02\xE0\x8E\x01a 5V[a\x01@\x8A\x01Ra!\x9E\x8Da\x03 \x8E\x01a 5V[\x86\x8A\x01Ra!\xB0\x8Da\x03`\x8E\x01a 5V[a\x01\x80\x8A\x01Ra\x03\xA0\x8C\x015\x94\x89\x01\x94\x90\x94Ra\x03\xC0\x8B\x015a\x01\xC0\x89\x01Ra\x03\xE0\x8B\x015\x92\x88\x01\x92\x90\x92Ra\x04\0\x8A\x015a\x02\0\x88\x01Ra\x04 \x8A\x015\x90\x87\x01Ra\x04@\x89\x015a\x02@\x87\x01Ra\x04`\x89\x015\x90\x86\x01R\x92\x87\x015a\x02\x80\x85\x01RPPa\x04\xA0\x85\x015\x90\x82\x01Ra\x04\xC0\x90\x93\x015a\x02\xC0\x84\x01RP\x92\x90\x91PV[_\x80`@\x83\x85\x03\x12\x15a\"CW_\x80\xFD[a\"L\x83a\x1F\x02V[\x91P` \x80\x84\x015`\x01`\x01`@\x1B\x03\x80\x82\x11\x15a\"hW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\"{W_\x80\xFD[\x815\x81\x81\x11\x15a\"\x8DWa\"\x8Da\x1FMV[a\"\x9F`\x1F\x82\x01`\x1F\x19\x16\x85\x01a\x1F\x8AV[\x91P\x80\x82R\x87\x84\x82\x85\x01\x01\x11\x15a\"\xB4W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80\x93PPPP\x92P\x92\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x1F\x18W_\x80\xFD[_` \x82\x84\x03\x12\x15a\"\xF4W_\x80\xFD[a\x1CN\x82a\"\xD1V[_\x80_\x80\x84\x86\x03a\x01 \x81\x12\x15a#\x12W_\x80\xFD[a#\x1C\x87\x87a\x1F\xD0V[\x94P`\x80`_\x19\x82\x01\x12\x15a#/W_\x80\xFD[P`@Q`\x80\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a#RWa#Ra\x1FMV[\x80`@RP``\x86\x015\x81R`\x80\x86\x015` \x82\x01R`\xA0\x86\x015`@\x82\x01R`\xC0\x86\x015``\x82\x01R\x80\x93PPa#\x8C`\xE0\x86\x01a\"\xD1V[\x91Pa#\x9Ba\x01\0\x86\x01a\x1F\x02V[\x90P\x92\x95\x91\x94P\x92PV[_[\x83\x81\x10\x15a#\xC0W\x81\x81\x01Q\x83\x82\x01R` \x01a#\xA8V[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra#\xE6\x81`@\x85\x01` \x87\x01a#\xA6V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_\x80`@\x83\x85\x03\x12\x15a$\x0BW_\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0C\x99Wa\x0C\x99a$\x1AV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x81a$cWa$ca$\x1AV[P_\x19\x01\x90V[\x80_[`\x07\x81\x10\x15a\x0E\x9AW\x81Q\x84R` \x93\x84\x01\x93\x90\x91\x01\x90`\x01\x01a$mV[a$\xA1\x82\x82Q\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[` \x81\x81\x01Q\x80Q`@\x85\x01R\x90\x81\x01Q``\x84\x01RP`@\x81\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP``\x81\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\x80\x81\x01Qa\x01\0a%\x04\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xA0\x83\x01Q\x91Pa\x01@a%$\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x84\x01Q\x92Pa\x01\x80a%D\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x85\x01Q\x93Pa\x01\xC0a%d\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x85\x01Q\x93Pa\x02\0\x92a%\x84\x87\x85\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x86\x01Q\x94Pa\x02@a%\xA5\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x86\x01Q\x94Pa\x02\x80\x92a%\xC5\x88\x85\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x87\x01Q\x95Pa\x02\xC0a%\xE6\x81\x8A\x01\x88\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x87\x01Q\x80Qa\x03\0\x8A\x01R` \x01Qa\x03 \x89\x01Ra\x01\xA0\x87\x01Qa\x03@\x89\x01R\x90\x86\x01Qa\x03`\x88\x01Ra\x01\xE0\x86\x01Qa\x03\x80\x88\x01R\x92\x85\x01Qa\x03\xA0\x87\x01Ra\x02 \x85\x01Qa\x03\xC0\x87\x01R\x91\x84\x01Qa\x03\xE0\x86\x01Ra\x02`\x84\x01Qa\x04\0\x86\x01R\x83\x01Qa\x04 \x85\x01Ra\x02\xA0\x83\x01Qa\x04@\x85\x01R\x90\x91\x01Qa\x04`\x90\x92\x01\x91\x90\x91RPV[_a\n`\x82\x01\x90P\x84Q\x82R` \x85\x01Q` \x83\x01R`@\x85\x01Qa&\xA2`@\x84\x01\x82\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[P``\x85\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP`\x80\x85\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\xA0\x85\x01Qa\x01\0a&\xEF\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x87\x01Q\x91Pa\x01@a'\x0F\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x88\x01Q\x92Pa\x01\x80a'/\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x88\x01Q\x92Pa\x01\xC0\x91a'O\x86\x84\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x89\x01Q\x93Pa\x02\0a'p\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x89\x01Q\x93Pa\x02@\x91a'\x90\x87\x84\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x8A\x01Q\x94Pa\x02\x80a'\xB1\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x8A\x01Q\x80Qa\x02\xC0\x89\x01R` \x90\x81\x01Qa\x02\xE0\x89\x01Ra\x01\xA0\x8B\x01Q\x80Qa\x03\0\x8A\x01R\x81\x01Qa\x03 \x89\x01R\x93\x8A\x01Q\x80Qa\x03@\x89\x01R\x84\x01Qa\x03`\x88\x01Ra\x01\xE0\x8A\x01Q\x80Qa\x03\x80\x89\x01R\x84\x01Qa\x03\xA0\x88\x01R\x89\x01Q\x80Qa\x03\xC0\x88\x01R\x83\x01Qa\x03\xE0\x87\x01Ra\x02 \x89\x01Q\x80Qa\x04\0\x88\x01R\x83\x01Qa\x04 \x87\x01R\x90\x88\x01Q\x80Qa\x04@\x87\x01R\x82\x01Qa\x04`\x86\x01Ra\x02`\x88\x01Q\x80Qa\x04\x80\x87\x01R\x90\x91\x01Qa\x04\xA0\x85\x01R\x86\x01Qa\x04\xC0\x84\x01RPa\x02\xA0\x85\x01Qa\x04\xE0\x83\x01Ra(\x88a\x05\0\x83\x01\x85a$jV[a(\x96a\x05\xE0\x83\x01\x84a$\x8CV[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a(\xAEW_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x1CNW_\x80\xFD[`\x01`\x01`@\x1B\x03\x82\x81\x16\x82\x82\x16\x03\x90\x80\x82\x11\x15a(\xDDWa(\xDDa$\x1AV[P\x92\x91PPV[_`\x01`\x01`@\x1B\x03\x80\x83\x16\x81\x81\x03a(\xFFWa(\xFFa$\x1AV[`\x01\x01\x93\x92PPPV[_` \x82\x84\x03\x12\x15a)\x19W_\x80\xFD[PQ\x91\x90PV[_\x82Qa)1\x81\x84` \x87\x01a#\xA6V[\x91\x90\x91\x01\x92\x91PPV\xFE6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x17\0\n", ); /**```solidity - struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } - ```*/ +struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct LightClientState { @@ -2428,11 +2631,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2462,13 +2667,15 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.viewNum, - ), - as alloy_sol_types::SolType>::tokenize( - &self.blockHeight, + as alloy_sol_types::SolType>::tokenize(&self.viewNum), + as alloy_sol_types::SolType>::tokenize(&self.blockHeight), + ::tokenize( + &self.blockCommRoot, ), - ::tokenize(&self.blockCommRoot), ) } #[inline] @@ -2476,50 +2683,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for LightClientState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -2533,9 +2754,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -2585,7 +2806,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -2604,16 +2827,23 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } - ```*/ +struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StakeTableState { @@ -2650,11 +2880,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2690,14 +2922,18 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.threshold, + as alloy_sol_types::SolType>::tokenize(&self.threshold), + ::tokenize( + &self.blsKeyComm, ), - ::tokenize(&self.blsKeyComm), ::tokenize( &self.schnorrKeyComm, ), - ::tokenize(&self.amountComm), + ::tokenize( + &self.amountComm, + ), ) } #[inline] @@ -2705,50 +2941,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for StakeTableState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -2762,9 +3012,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -2819,7 +3069,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -2840,17 +3092,24 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`. - ```solidity - error AddressEmptyCode(address target); - ```*/ +```solidity +error AddressEmptyCode(address target); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct AddressEmptyCode { @@ -2871,11 +3130,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2895,7 +3156,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for AddressEmptyCode { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "AddressEmptyCode(address)"; const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8]; #[inline] @@ -2915,9 +3178,9 @@ pub mod LightClient { } }; /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`. - ```solidity - error ERC1967InvalidImplementation(address implementation); - ```*/ +```solidity +error ERC1967InvalidImplementation(address implementation); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967InvalidImplementation { @@ -2938,33 +3201,37 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: ERC1967InvalidImplementation) -> Self { (value.implementation,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for ERC1967InvalidImplementation { + impl ::core::convert::From> + for ERC1967InvalidImplementation { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - implementation: tuple.0, - } + Self { implementation: tuple.0 } } } #[automatically_derived] impl alloy_sol_types::SolError for ERC1967InvalidImplementation { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)"; const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8]; #[inline] @@ -2984,9 +3251,9 @@ pub mod LightClient { } }; /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`. - ```solidity - error ERC1967NonPayable(); - ```*/ +```solidity +error ERC1967NonPayable(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967NonPayable {} @@ -3004,11 +3271,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3028,7 +3297,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for ERC1967NonPayable { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967NonPayable()"; const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8]; #[inline] @@ -3044,9 +3315,9 @@ pub mod LightClient { } }; /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`. - ```solidity - error FailedInnerCall(); - ```*/ +```solidity +error FailedInnerCall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FailedInnerCall {} @@ -3064,11 +3335,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3088,7 +3361,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for FailedInnerCall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FailedInnerCall()"; const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8]; #[inline] @@ -3104,9 +3379,9 @@ pub mod LightClient { } }; /**Custom error with signature `InsufficientSnapshotHistory()` and selector `0xb0b43877`. - ```solidity - error InsufficientSnapshotHistory(); - ```*/ +```solidity +error InsufficientSnapshotHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InsufficientSnapshotHistory {} @@ -3124,23 +3399,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InsufficientSnapshotHistory) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InsufficientSnapshotHistory { + impl ::core::convert::From> + for InsufficientSnapshotHistory { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3148,7 +3427,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InsufficientSnapshotHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InsufficientSnapshotHistory()"; const SELECTOR: [u8; 4] = [176u8, 180u8, 56u8, 119u8]; #[inline] @@ -3164,9 +3445,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidAddress()` and selector `0xe6c4247b`. - ```solidity - error InvalidAddress(); - ```*/ +```solidity +error InvalidAddress(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidAddress {} @@ -3184,11 +3465,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3208,7 +3491,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidAddress { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidAddress()"; const SELECTOR: [u8; 4] = [230u8, 196u8, 36u8, 123u8]; #[inline] @@ -3224,9 +3509,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidArgs()` and selector `0xa1ba07ee`. - ```solidity - error InvalidArgs(); - ```*/ +```solidity +error InvalidArgs(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidArgs {} @@ -3244,11 +3529,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3268,7 +3555,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidArgs { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidArgs()"; const SELECTOR: [u8; 4] = [161u8, 186u8, 7u8, 238u8]; #[inline] @@ -3284,9 +3573,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidHotShotBlockForCommitmentCheck()` and selector `0x615a9264`. - ```solidity - error InvalidHotShotBlockForCommitmentCheck(); - ```*/ +```solidity +error InvalidHotShotBlockForCommitmentCheck(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidHotShotBlockForCommitmentCheck {} @@ -3304,23 +3593,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InvalidHotShotBlockForCommitmentCheck) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InvalidHotShotBlockForCommitmentCheck { + impl ::core::convert::From> + for InvalidHotShotBlockForCommitmentCheck { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3328,7 +3621,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidHotShotBlockForCommitmentCheck { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidHotShotBlockForCommitmentCheck()"; const SELECTOR: [u8; 4] = [97u8, 90u8, 146u8, 100u8]; #[inline] @@ -3344,9 +3639,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`. - ```solidity - error InvalidInitialization(); - ```*/ +```solidity +error InvalidInitialization(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidInitialization {} @@ -3364,11 +3659,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3388,7 +3685,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidInitialization { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidInitialization()"; const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8]; #[inline] @@ -3404,9 +3703,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidMaxStateHistory()` and selector `0xf4a0eee0`. - ```solidity - error InvalidMaxStateHistory(); - ```*/ +```solidity +error InvalidMaxStateHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidMaxStateHistory {} @@ -3424,11 +3723,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3448,7 +3749,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidMaxStateHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidMaxStateHistory()"; const SELECTOR: [u8; 4] = [244u8, 160u8, 238u8, 224u8]; #[inline] @@ -3464,9 +3767,9 @@ pub mod LightClient { } }; /**Custom error with signature `InvalidProof()` and selector `0x09bde339`. - ```solidity - error InvalidProof(); - ```*/ +```solidity +error InvalidProof(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidProof {} @@ -3484,11 +3787,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3508,7 +3813,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for InvalidProof { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidProof()"; const SELECTOR: [u8; 4] = [9u8, 189u8, 227u8, 57u8]; #[inline] @@ -3524,9 +3831,9 @@ pub mod LightClient { } }; /**Custom error with signature `NoChangeRequired()` and selector `0xa863aec9`. - ```solidity - error NoChangeRequired(); - ```*/ +```solidity +error NoChangeRequired(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NoChangeRequired {} @@ -3544,11 +3851,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3568,7 +3877,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for NoChangeRequired { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NoChangeRequired()"; const SELECTOR: [u8; 4] = [168u8, 99u8, 174u8, 201u8]; #[inline] @@ -3584,9 +3895,9 @@ pub mod LightClient { } }; /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`. - ```solidity - error NotInitializing(); - ```*/ +```solidity +error NotInitializing(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NotInitializing {} @@ -3604,11 +3915,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3628,7 +3941,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for NotInitializing { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NotInitializing()"; const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8]; #[inline] @@ -3644,9 +3959,9 @@ pub mod LightClient { } }; /**Custom error with signature `OutdatedState()` and selector `0x051c46ef`. - ```solidity - error OutdatedState(); - ```*/ +```solidity +error OutdatedState(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OutdatedState {} @@ -3664,11 +3979,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3688,7 +4005,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for OutdatedState { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OutdatedState()"; const SELECTOR: [u8; 4] = [5u8, 28u8, 70u8, 239u8]; #[inline] @@ -3704,9 +4023,9 @@ pub mod LightClient { } }; /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`. - ```solidity - error OwnableInvalidOwner(address owner); - ```*/ +```solidity +error OwnableInvalidOwner(address owner); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableInvalidOwner { @@ -3727,11 +4046,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3751,7 +4072,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for OwnableInvalidOwner { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableInvalidOwner(address)"; const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8]; #[inline] @@ -3771,9 +4094,9 @@ pub mod LightClient { } }; /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`. - ```solidity - error OwnableUnauthorizedAccount(address account); - ```*/ +```solidity +error OwnableUnauthorizedAccount(address account); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableUnauthorizedAccount { @@ -3794,23 +4117,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: OwnableUnauthorizedAccount) -> Self { (value.account,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for OwnableUnauthorizedAccount { + impl ::core::convert::From> + for OwnableUnauthorizedAccount { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { account: tuple.0 } } @@ -3818,7 +4145,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for OwnableUnauthorizedAccount { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)"; const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8]; #[inline] @@ -3838,9 +4167,9 @@ pub mod LightClient { } }; /**Custom error with signature `ProverNotPermissioned()` and selector `0xa3a64780`. - ```solidity - error ProverNotPermissioned(); - ```*/ +```solidity +error ProverNotPermissioned(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ProverNotPermissioned {} @@ -3858,11 +4187,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3882,7 +4213,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for ProverNotPermissioned { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ProverNotPermissioned()"; const SELECTOR: [u8; 4] = [163u8, 166u8, 71u8, 128u8]; #[inline] @@ -3898,9 +4231,9 @@ pub mod LightClient { } }; /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`. - ```solidity - error UUPSUnauthorizedCallContext(); - ```*/ +```solidity +error UUPSUnauthorizedCallContext(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnauthorizedCallContext {} @@ -3918,23 +4251,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnauthorizedCallContext) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnauthorizedCallContext { + impl ::core::convert::From> + for UUPSUnauthorizedCallContext { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3942,7 +4279,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()"; const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8]; #[inline] @@ -3958,9 +4297,9 @@ pub mod LightClient { } }; /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`. - ```solidity - error UUPSUnsupportedProxiableUUID(bytes32 slot); - ```*/ +```solidity +error UUPSUnsupportedProxiableUUID(bytes32 slot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnsupportedProxiableUUID { @@ -3981,23 +4320,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnsupportedProxiableUUID) -> Self { (value.slot,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnsupportedProxiableUUID { + impl ::core::convert::From> + for UUPSUnsupportedProxiableUUID { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { slot: tuple.0 } } @@ -4005,7 +4348,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)"; const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8]; #[inline] @@ -4025,9 +4370,9 @@ pub mod LightClient { } }; /**Custom error with signature `WrongStakeTableUsed()` and selector `0x51618089`. - ```solidity - error WrongStakeTableUsed(); - ```*/ +```solidity +error WrongStakeTableUsed(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct WrongStakeTableUsed {} @@ -4045,11 +4390,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4069,7 +4416,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolError for WrongStakeTableUsed { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "WrongStakeTableUsed()"; const SELECTOR: [u8; 4] = [81u8, 97u8, 128u8, 137u8]; #[inline] @@ -4085,9 +4434,9 @@ pub mod LightClient { } }; /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`. - ```solidity - event Initialized(uint64 version); - ```*/ +```solidity +event Initialized(uint64 version); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4110,15 +4459,45 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for Initialized { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Initialized(uint64)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4133,20 +4512,22 @@ pub mod LightClient { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.version, - ), + as alloy_sol_types::SolType>::tokenize(&self.version), ) } #[inline] @@ -4161,7 +4542,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4183,9 +4566,9 @@ pub mod LightClient { } }; /**Event with signature `NewState(uint64,uint64,uint256)` and selector `0xa04a773924505a418564363725f56832f5772e6b8d0dbd6efce724dfe803dae6`. - ```solidity - event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4212,19 +4595,49 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for NewState { type DataTuple<'a> = (BN254::ScalarField,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, ); const SIGNATURE: &'static str = "NewState(uint64,uint64,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, - 37u8, 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, - 252u8, 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4243,19 +4656,23 @@ pub mod LightClient { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { - (::tokenize( - &self.blockCommRoot, - ),) + ( + ::tokenize( + &self.blockCommRoot, + ), + ) } #[inline] fn topics(&self) -> ::RustType { @@ -4273,7 +4690,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.viewNum); @@ -4301,9 +4720,9 @@ pub mod LightClient { } }; /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. - ```solidity - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - ```*/ +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4328,19 +4747,49 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for OwnershipTransferred { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, - 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, - 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4358,11 +4807,13 @@ pub mod LightClient { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4386,7 +4837,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.previousOwner, ); @@ -4414,9 +4867,9 @@ pub mod LightClient { } }; /**Event with signature `PermissionedProverNotRequired()` and selector `0x9a5f57de856dd668c54dd95e5c55df93432171cbca49a8776d5620ea59c02450`. - ```solidity - event PermissionedProverNotRequired(); - ```*/ +```solidity +event PermissionedProverNotRequired(); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4436,15 +4889,45 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverNotRequired { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverNotRequired()"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4459,11 +4942,13 @@ pub mod LightClient { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4483,7 +4968,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4499,15 +4986,17 @@ pub mod LightClient { #[automatically_derived] impl From<&PermissionedProverNotRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverNotRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverNotRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `PermissionedProverRequired(address)` and selector `0x8017bb887fdf8fca4314a9d40f6e73b3b81002d67e5cfa85d88173af6aa46072`. - ```solidity - event PermissionedProverRequired(address permissionedProver); - ```*/ +```solidity +event PermissionedProverRequired(address permissionedProver); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4530,15 +5019,45 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverRequired { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverRequired(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, - 212u8, 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, - 133u8, 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4546,20 +5065,20 @@ pub mod LightClient { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - permissionedProver: data.0, - } + Self { permissionedProver: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4583,7 +5102,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4599,15 +5120,17 @@ pub mod LightClient { #[automatically_derived] impl From<&PermissionedProverRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `Upgrade(address)` and selector `0xf78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d`. - ```solidity - event Upgrade(address implementation); - ```*/ +```solidity +event Upgrade(address implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4630,15 +5153,45 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgrade { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Upgrade(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, - 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4646,20 +5199,20 @@ pub mod LightClient { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: data.0, - } + Self { implementation: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4683,7 +5236,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4705,9 +5260,9 @@ pub mod LightClient { } }; /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. - ```solidity - event Upgraded(address indexed implementation); - ```*/ +```solidity +event Upgraded(address indexed implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4730,18 +5285,48 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgraded { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Upgraded(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, - 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, - 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4749,20 +5334,20 @@ pub mod LightClient { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: topics.1, - } + Self { implementation: topics.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4782,7 +5367,9 @@ pub mod LightClient { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.implementation, ); @@ -4807,9 +5394,9 @@ pub mod LightClient { } }; /**Constructor`. - ```solidity - constructor(); - ```*/ +```solidity +constructor(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct constructorCall {} @@ -4822,11 +5409,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4847,7 +5436,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolConstructor for constructorCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -4861,9 +5452,9 @@ pub mod LightClient { } }; /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`. - ```solidity - function UPGRADE_INTERFACE_VERSION() external view returns (string memory); - ```*/ +```solidity +function UPGRADE_INTERFACE_VERSION() external view returns (string memory); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UPGRADE_INTERFACE_VERSIONCall {} @@ -4889,23 +5480,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONCall { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -4918,23 +5513,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONReturn { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -4943,10 +5542,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = UPGRADE_INTERFACE_VERSIONReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()"; const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8]; #[inline] @@ -4964,17 +5567,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `currentBlockNumber()` and selector `0x378ec23b`. - ```solidity - function currentBlockNumber() external view returns (uint256); - ```*/ +```solidity +function currentBlockNumber() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct currentBlockNumberCall {} @@ -5000,23 +5603,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberCall { + impl ::core::convert::From> + for currentBlockNumberCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5026,26 +5633,32 @@ pub mod LightClient { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberReturn { + impl ::core::convert::From> + for currentBlockNumberReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5054,10 +5667,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for currentBlockNumberCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = currentBlockNumberReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "currentBlockNumber()"; const SELECTOR: [u8; 4] = [55u8, 142u8, 194u8, 59u8]; #[inline] @@ -5075,17 +5692,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `disablePermissionedProverMode()` and selector `0x69cc6a04`. - ```solidity - function disablePermissionedProverMode() external; - ```*/ +```solidity +function disablePermissionedProverMode() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct disablePermissionedProverModeCall {} @@ -5108,23 +5725,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeCall { + impl ::core::convert::From> + for disablePermissionedProverModeCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5137,23 +5758,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeReturn { + impl ::core::convert::From> + for disablePermissionedProverModeReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5162,10 +5787,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for disablePermissionedProverModeCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = disablePermissionedProverModeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "disablePermissionedProverMode()"; const SELECTOR: [u8; 4] = [105u8, 204u8, 106u8, 4u8]; #[inline] @@ -5183,17 +5812,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `finalizedState()` and selector `0x9fdb54a7`. - ```solidity - function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct finalizedStateCall {} @@ -5223,11 +5852,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5260,23 +5891,27 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: finalizedStateReturn) -> Self { (value.viewNum, value.blockHeight, value.blockCommRoot) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for finalizedStateReturn { + impl ::core::convert::From> + for finalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { viewNum: tuple.0, @@ -5289,14 +5924,18 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for finalizedStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = finalizedStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "finalizedState()"; const SELECTOR: [u8; 4] = [159u8, 219u8, 84u8, 167u8]; #[inline] @@ -5314,17 +5953,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisStakeTableState()` and selector `0x426d3194`. - ```solidity - function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); - ```*/ +```solidity +function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStakeTableStateCall {} @@ -5356,23 +5995,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateCall { + impl ::core::convert::From> + for genesisStakeTableStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5395,16 +6038,19 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateReturn) -> Self { ( value.threshold, @@ -5416,7 +6062,8 @@ pub mod LightClient { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateReturn { + impl ::core::convert::From> + for genesisStakeTableStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { threshold: tuple.0, @@ -5430,7 +6077,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStakeTableStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStakeTableStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<256>, @@ -5438,7 +6087,9 @@ pub mod LightClient { BN254::ScalarField, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisStakeTableState()"; const SELECTOR: [u8; 4] = [66u8, 109u8, 49u8, 148u8]; #[inline] @@ -5456,17 +6107,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisState()` and selector `0xd24d933d`. - ```solidity - function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStateCall {} @@ -5496,11 +6147,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5533,11 +6186,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5562,14 +6217,18 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisState()"; const SELECTOR: [u8; 4] = [210u8, 77u8, 147u8, 61u8]; #[inline] @@ -5587,17 +6246,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getHotShotCommitment(uint256)` and selector `0x8584d23f`. - ```solidity - function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); - ```*/ +```solidity +function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getHotShotCommitmentCall { @@ -5625,26 +6284,32 @@ pub mod LightClient { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentCall) -> Self { (value.hotShotBlockHeight,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentCall { + impl ::core::convert::From> + for getHotShotCommitmentCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockHeight: tuple.0, @@ -5654,8 +6319,10 @@ pub mod LightClient { } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); + type UnderlyingSolTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( ::RustType, @@ -5663,23 +6330,27 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentReturn) -> Self { (value.hotShotBlockCommRoot, value.hotshotBlockHeight) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentReturn { + impl ::core::convert::From> + for getHotShotCommitmentReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockCommRoot: tuple.0, @@ -5691,10 +6362,17 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for getHotShotCommitmentCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getHotShotCommitmentReturn; - type ReturnTuple<'a> = (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getHotShotCommitment(uint256)"; const SELECTOR: [u8; 4] = [133u8, 132u8, 210u8, 63u8]; #[inline] @@ -5706,9 +6384,9 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.hotShotBlockHeight, - ), + as alloy_sol_types::SolType>::tokenize(&self.hotShotBlockHeight), ) } #[inline] @@ -5716,17 +6394,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getStateHistoryCount()` and selector `0xf9e50d19`. - ```solidity - function getStateHistoryCount() external view returns (uint256); - ```*/ +```solidity +function getStateHistoryCount() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getStateHistoryCountCall {} @@ -5752,23 +6430,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountCall { + impl ::core::convert::From> + for getStateHistoryCountCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5778,26 +6460,32 @@ pub mod LightClient { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountReturn { + impl ::core::convert::From> + for getStateHistoryCountReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5806,10 +6494,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for getStateHistoryCountCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getStateHistoryCountReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getStateHistoryCount()"; const SELECTOR: [u8; 4] = [249u8, 229u8, 13u8, 25u8]; #[inline] @@ -5827,17 +6519,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getVersion()` and selector `0x0d8e6e2c`. - ```solidity - function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); - ```*/ +```solidity +function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getVersionCall {} @@ -5867,11 +6559,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5900,11 +6594,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (u8, u8, u8); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5929,14 +6625,18 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for getVersionCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getVersionReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getVersion()"; const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8]; #[inline] @@ -5954,17 +6654,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)` and selector `0x9baa3cc9`. - ```solidity - function initialize(LightClientState memory _genesis, StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; - ```*/ +```solidity +function initialize(LightClientState memory _genesis, StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializeCall { @@ -6006,11 +6706,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6045,11 +6747,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6075,10 +6779,14 @@ pub mod LightClient { alloy::sol_types::sol_data::Uint<32>, alloy::sol_types::sol_data::Address, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)"; const SELECTOR: [u8; 4] = [155u8, 170u8, 60u8, 201u8]; #[inline] @@ -6090,11 +6798,15 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize(&self._genesis), + ::tokenize( + &self._genesis, + ), ::tokenize( &self._genesisStakeTableState, ), - as alloy_sol_types::SolType>::tokenize( + as alloy_sol_types::SolType>::tokenize( &self._stateHistoryRetentionPeriod, ), ::tokenize( @@ -6107,17 +6819,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `isPermissionedProverEnabled()` and selector `0x826e41fc`. - ```solidity - function isPermissionedProverEnabled() external view returns (bool); - ```*/ +```solidity +function isPermissionedProverEnabled() external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct isPermissionedProverEnabledCall {} @@ -6143,23 +6855,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledCall { + impl ::core::convert::From> + for isPermissionedProverEnabledCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6172,23 +6888,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledReturn { + impl ::core::convert::From> + for isPermissionedProverEnabledReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6197,10 +6917,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for isPermissionedProverEnabledCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = isPermissionedProverEnabledReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "isPermissionedProverEnabled()"; const SELECTOR: [u8; 4] = [130u8, 110u8, 65u8, 252u8]; #[inline] @@ -6218,17 +6942,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `lagOverEscapeHatchThreshold(uint256,uint256)` and selector `0xe0303301`. - ```solidity - function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 blockThreshold) external view returns (bool); - ```*/ +```solidity +function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 blockThreshold) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct lagOverEscapeHatchThresholdCall { @@ -6265,23 +6989,27 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdCall) -> Self { (value.blockNumber, value.blockThreshold) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdCall { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { blockNumber: tuple.0, @@ -6297,23 +7025,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdReturn { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6325,10 +7057,14 @@ pub mod LightClient { alloy::sol_types::sol_data::Uint<256>, alloy::sol_types::sol_data::Uint<256>, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = lagOverEscapeHatchThresholdReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "lagOverEscapeHatchThreshold(uint256,uint256)"; const SELECTOR: [u8; 4] = [224u8, 48u8, 51u8, 1u8]; #[inline] @@ -6340,12 +7076,12 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.blockNumber, - ), - as alloy_sol_types::SolType>::tokenize( - &self.blockThreshold, - ), + as alloy_sol_types::SolType>::tokenize(&self.blockNumber), + as alloy_sol_types::SolType>::tokenize(&self.blockThreshold), ) } #[inline] @@ -6353,17 +7089,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x2063d4f7`. - ```solidity - function newFinalizedState(LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; - ```*/ +```solidity +function newFinalizedState(LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct newFinalizedStateCall { @@ -6394,23 +7130,27 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateCall) -> Self { (value.newState, value.proof) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateCall { + impl ::core::convert::From> + for newFinalizedStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newState: tuple.0, @@ -6426,23 +7166,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateReturn { + impl ::core::convert::From> + for newFinalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6451,10 +7195,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for newFinalizedStateCall { type Parameters<'a> = (LightClientState, IPlonkVerifier::PlonkProof); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = newFinalizedStateReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [32u8, 99u8, 212u8, 247u8]; #[inline] @@ -6466,8 +7214,12 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize(&self.newState), - ::tokenize(&self.proof), + ::tokenize( + &self.newState, + ), + ::tokenize( + &self.proof, + ), ) } #[inline] @@ -6475,17 +7227,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `owner()` and selector `0x8da5cb5b`. - ```solidity - function owner() external view returns (address); - ```*/ +```solidity +function owner() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ownerCall {} @@ -6511,11 +7263,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6540,11 +7294,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6565,10 +7321,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for ownerCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = ownerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "owner()"; const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; #[inline] @@ -6586,17 +7346,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `permissionedProver()` and selector `0x313df7b1`. - ```solidity - function permissionedProver() external view returns (address); - ```*/ +```solidity +function permissionedProver() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct permissionedProverCall {} @@ -6622,23 +7382,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverCall { + impl ::core::convert::From> + for permissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6651,23 +7415,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverReturn { + impl ::core::convert::From> + for permissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6676,10 +7444,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for permissionedProverCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = permissionedProverReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "permissionedProver()"; const SELECTOR: [u8; 4] = [49u8, 61u8, 247u8, 177u8]; #[inline] @@ -6697,17 +7469,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `proxiableUUID()` and selector `0x52d1902d`. - ```solidity - function proxiableUUID() external view returns (bytes32); - ```*/ +```solidity +function proxiableUUID() external view returns (bytes32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct proxiableUUIDCall {} @@ -6733,11 +7505,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6762,11 +7536,13 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6787,10 +7563,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for proxiableUUIDCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = proxiableUUIDReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "proxiableUUID()"; const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8]; #[inline] @@ -6808,17 +7588,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `renounceOwnership()` and selector `0x715018a6`. - ```solidity - function renounceOwnership() external; - ```*/ +```solidity +function renounceOwnership() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct renounceOwnershipCall {} @@ -6841,23 +7621,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipCall { + impl ::core::convert::From> + for renounceOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6870,23 +7654,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipReturn { + impl ::core::convert::From> + for renounceOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6895,10 +7683,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for renounceOwnershipCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = renounceOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "renounceOwnership()"; const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; #[inline] @@ -6916,17 +7708,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setPermissionedProver(address)` and selector `0x013fa5fc`. - ```solidity - function setPermissionedProver(address prover) external; - ```*/ +```solidity +function setPermissionedProver(address prover) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setPermissionedProverCall { @@ -6952,23 +7744,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverCall) -> Self { (value.prover,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverCall { + impl ::core::convert::From> + for setPermissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { prover: tuple.0 } } @@ -6981,23 +7777,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverReturn { + impl ::core::convert::From> + for setPermissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7006,10 +7806,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for setPermissionedProverCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setPermissionedProverReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setPermissionedProver(address)"; const SELECTOR: [u8; 4] = [1u8, 63u8, 165u8, 252u8]; #[inline] @@ -7031,17 +7835,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setstateHistoryRetentionPeriod(uint32)` and selector `0x96c1ca61`. - ```solidity - function setstateHistoryRetentionPeriod(uint32 historySeconds) external; - ```*/ +```solidity +function setstateHistoryRetentionPeriod(uint32 historySeconds) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setstateHistoryRetentionPeriodCall { @@ -7067,27 +7871,29 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodCall) -> Self { (value.historySeconds,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - historySeconds: tuple.0, - } + Self { historySeconds: tuple.0 } } } } @@ -7098,23 +7904,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7123,10 +7933,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for setstateHistoryRetentionPeriodCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setstateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setstateHistoryRetentionPeriod(uint32)"; const SELECTOR: [u8; 4] = [150u8, 193u8, 202u8, 97u8]; #[inline] @@ -7138,9 +7952,9 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.historySeconds, - ), + as alloy_sol_types::SolType>::tokenize(&self.historySeconds), ) } #[inline] @@ -7148,17 +7962,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryCommitments(uint256)` and selector `0x02b592f3`. - ```solidity - function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); - ```*/ +```solidity +function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryCommitmentsCall { @@ -7190,26 +8004,32 @@ pub mod LightClient { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsCall) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsCall { + impl ::core::convert::From> + for stateHistoryCommitmentsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7232,16 +8052,19 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsReturn) -> Self { ( value.l1BlockHeight, @@ -7253,7 +8076,8 @@ pub mod LightClient { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsReturn { + impl ::core::convert::From> + for stateHistoryCommitmentsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { l1BlockHeight: tuple.0, @@ -7267,7 +8091,9 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryCommitmentsCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryCommitmentsReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, @@ -7275,7 +8101,9 @@ pub mod LightClient { alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryCommitments(uint256)"; const SELECTOR: [u8; 4] = [2u8, 181u8, 146u8, 243u8]; #[inline] @@ -7287,9 +8115,9 @@ pub mod LightClient { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self._0, - ), + as alloy_sol_types::SolType>::tokenize(&self._0), ) } #[inline] @@ -7297,17 +8125,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryFirstIndex()` and selector `0x2f79889d`. - ```solidity - function stateHistoryFirstIndex() external view returns (uint64); - ```*/ +```solidity +function stateHistoryFirstIndex() external view returns (uint64); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryFirstIndexCall {} @@ -7333,23 +8161,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexCall { + impl ::core::convert::From> + for stateHistoryFirstIndexCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7362,23 +8194,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (u64,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexReturn { + impl ::core::convert::From> + for stateHistoryFirstIndexReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7387,10 +8223,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryFirstIndexCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryFirstIndexReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryFirstIndex()"; const SELECTOR: [u8; 4] = [47u8, 121u8, 136u8, 157u8]; #[inline] @@ -7408,17 +8248,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryRetentionPeriod()` and selector `0xc23b9e9e`. - ```solidity - function stateHistoryRetentionPeriod() external view returns (uint32); - ```*/ +```solidity +function stateHistoryRetentionPeriod() external view returns (uint32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryRetentionPeriodCall {} @@ -7444,23 +8284,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for stateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7473,23 +8317,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for stateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7498,10 +8346,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryRetentionPeriodCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryRetentionPeriod()"; const SELECTOR: [u8; 4] = [194u8, 59u8, 158u8, 158u8]; #[inline] @@ -7519,17 +8371,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. - ```solidity - function transferOwnership(address newOwner) external; - ```*/ +```solidity +function transferOwnership(address newOwner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct transferOwnershipCall { @@ -7555,23 +8407,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipCall) -> Self { (value.newOwner,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipCall { + impl ::core::convert::From> + for transferOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newOwner: tuple.0 } } @@ -7584,23 +8440,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipReturn { + impl ::core::convert::From> + for transferOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7609,10 +8469,14 @@ pub mod LightClient { #[automatically_derived] impl alloy_sol_types::SolCall for transferOwnershipCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = transferOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "transferOwnership(address)"; const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; #[inline] @@ -7634,17 +8498,17 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`. - ```solidity - function upgradeToAndCall(address newImplementation, bytes memory data) external payable; - ```*/ +```solidity +function upgradeToAndCall(address newImplementation, bytes memory data) external payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct upgradeToAndCallCall { @@ -7678,23 +8542,27 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallCall) -> Self { (value.newImplementation, value.data) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallCall { + impl ::core::convert::From> + for upgradeToAndCallCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newImplementation: tuple.0, @@ -7710,23 +8578,27 @@ pub mod LightClient { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallReturn { + impl ::core::convert::From> + for upgradeToAndCallReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7738,10 +8610,14 @@ pub mod LightClient { alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Bytes, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = upgradeToAndCallReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)"; const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8]; #[inline] @@ -7766,10 +8642,10 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -7869,66 +8745,74 @@ pub mod LightClient { match self { Self::UPGRADE_INTERFACE_VERSION(_) => { ::SELECTOR - }, + } Self::currentBlockNumber(_) => { ::SELECTOR - }, + } Self::disablePermissionedProverMode(_) => { ::SELECTOR - }, + } Self::finalizedState(_) => { ::SELECTOR - }, + } Self::genesisStakeTableState(_) => { ::SELECTOR - }, - Self::genesisState(_) => ::SELECTOR, + } + Self::genesisState(_) => { + ::SELECTOR + } Self::getHotShotCommitment(_) => { ::SELECTOR - }, + } Self::getStateHistoryCount(_) => { ::SELECTOR - }, - Self::getVersion(_) => ::SELECTOR, - Self::initialize(_) => ::SELECTOR, + } + Self::getVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } Self::isPermissionedProverEnabled(_) => { ::SELECTOR - }, + } Self::lagOverEscapeHatchThreshold(_) => { ::SELECTOR - }, + } Self::newFinalizedState(_) => { ::SELECTOR - }, + } Self::owner(_) => ::SELECTOR, Self::permissionedProver(_) => { ::SELECTOR - }, - Self::proxiableUUID(_) => ::SELECTOR, + } + Self::proxiableUUID(_) => { + ::SELECTOR + } Self::renounceOwnership(_) => { ::SELECTOR - }, + } Self::setPermissionedProver(_) => { ::SELECTOR - }, + } Self::setstateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::stateHistoryCommitments(_) => { ::SELECTOR - }, + } Self::stateHistoryFirstIndex(_) => { ::SELECTOR - }, + } Self::stateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::transferOwnership(_) => { ::SELECTOR - }, + } Self::upgradeToAndCall(_) => { ::SELECTOR - }, + } } } #[inline] @@ -7946,309 +8830,330 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - static DECODE_SHIMS: &[fn(&[u8], bool) -> alloy_sol_types::Result] = - &[ - { - fn setPermissionedProver( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + static DECODE_SHIMS: &[fn( + &[u8], + bool, + ) -> alloy_sol_types::Result] = &[ + { + fn setPermissionedProver( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::setPermissionedProver) - } - setPermissionedProver - }, - { - fn stateHistoryCommitments( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + setPermissionedProver + }, + { + fn stateHistoryCommitments( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::stateHistoryCommitments) - } - stateHistoryCommitments - }, - { - fn getVersion( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + stateHistoryCommitments + }, + { + fn getVersion( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::getVersion) - } - getVersion - }, - { - fn newFinalizedState( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + getVersion + }, + { + fn newFinalizedState( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::newFinalizedState) - } - newFinalizedState - }, - { - fn stateHistoryFirstIndex( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + newFinalizedState + }, + { + fn stateHistoryFirstIndex( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::stateHistoryFirstIndex) - } - stateHistoryFirstIndex - }, - { - fn permissionedProver( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + stateHistoryFirstIndex + }, + { + fn permissionedProver( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::permissionedProver) - } - permissionedProver - }, - { - fn currentBlockNumber( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + permissionedProver + }, + { + fn currentBlockNumber( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::currentBlockNumber) - } - currentBlockNumber - }, - { - fn genesisStakeTableState( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + currentBlockNumber + }, + { + fn genesisStakeTableState( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::genesisStakeTableState) - } - genesisStakeTableState - }, - { - fn upgradeToAndCall( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + genesisStakeTableState + }, + { + fn upgradeToAndCall( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::upgradeToAndCall) - } - upgradeToAndCall - }, - { - fn proxiableUUID( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + upgradeToAndCall + }, + { + fn proxiableUUID( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::proxiableUUID) - } - proxiableUUID - }, - { - fn disablePermissionedProverMode( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + proxiableUUID + }, + { + fn disablePermissionedProverMode( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::disablePermissionedProverMode) - } - disablePermissionedProverMode - }, - { - fn renounceOwnership( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + disablePermissionedProverMode + }, + { + fn renounceOwnership( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::renounceOwnership) - } - renounceOwnership - }, - { - fn isPermissionedProverEnabled( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + renounceOwnership + }, + { + fn isPermissionedProverEnabled( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::isPermissionedProverEnabled) - } - isPermissionedProverEnabled - }, - { - fn getHotShotCommitment( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + isPermissionedProverEnabled + }, + { + fn getHotShotCommitment( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::getHotShotCommitment) - } - getHotShotCommitment - }, - { - fn owner( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) - .map(LightClientCalls::owner) - } - owner - }, - { - fn setstateHistoryRetentionPeriod( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + getHotShotCommitment + }, + { + fn owner( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, + ) + .map(LightClientCalls::owner) + } + owner + }, + { + fn setstateHistoryRetentionPeriod( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::setstateHistoryRetentionPeriod) - } - setstateHistoryRetentionPeriod - }, - { - fn initialize( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + setstateHistoryRetentionPeriod + }, + { + fn initialize( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::initialize) - } - initialize - }, - { - fn finalizedState( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + initialize + }, + { + fn finalizedState( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::finalizedState) - } - finalizedState - }, - { - fn UPGRADE_INTERFACE_VERSION( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + finalizedState + }, + { + fn UPGRADE_INTERFACE_VERSION( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::UPGRADE_INTERFACE_VERSION) - } - UPGRADE_INTERFACE_VERSION - }, - { - fn stateHistoryRetentionPeriod( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + UPGRADE_INTERFACE_VERSION + }, + { + fn stateHistoryRetentionPeriod( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::stateHistoryRetentionPeriod) - } - stateHistoryRetentionPeriod - }, - { - fn genesisState( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + stateHistoryRetentionPeriod + }, + { + fn genesisState( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::genesisState) - } - genesisState - }, - { - fn lagOverEscapeHatchThreshold( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( + } + genesisState + }, + { + fn lagOverEscapeHatchThreshold( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( data, validate, ) .map(LightClientCalls::lagOverEscapeHatchThreshold) - } - lagOverEscapeHatchThreshold - }, - { - fn transferOwnership( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + lagOverEscapeHatchThreshold + }, + { + fn transferOwnership( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::transferOwnership) - } - transferOwnership - }, - { - fn getStateHistoryCount( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw( - data, validate, + } + transferOwnership + }, + { + fn getStateHistoryCount( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, ) .map(LightClientCalls::getStateHistoryCount) - } - getStateHistoryCount - }, - ]; + } + getStateHistoryCount + }, + ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -8376,100 +9281,145 @@ pub mod LightClient { match self { Self::UPGRADE_INTERFACE_VERSION(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::currentBlockNumber(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::disablePermissionedProverMode(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::finalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::genesisStakeTableState(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::genesisState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::getHotShotCommitment(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getStateHistoryCount(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getVersion(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::initialize(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::isPermissionedProverEnabled(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::lagOverEscapeHatchThreshold(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::newFinalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::owner(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::permissionedProver(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::proxiableUUID(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::renounceOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setPermissionedProver(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::setstateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryCommitments(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryFirstIndex(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::transferOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::upgradeToAndCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -8557,56 +9507,64 @@ pub mod LightClient { match self { Self::AddressEmptyCode(_) => { ::SELECTOR - }, + } Self::ERC1967InvalidImplementation(_) => { ::SELECTOR - }, + } Self::ERC1967NonPayable(_) => { ::SELECTOR - }, + } Self::FailedInnerCall(_) => { ::SELECTOR - }, + } Self::InsufficientSnapshotHistory(_) => { ::SELECTOR - }, - Self::InvalidAddress(_) => ::SELECTOR, - Self::InvalidArgs(_) => ::SELECTOR, + } + Self::InvalidAddress(_) => { + ::SELECTOR + } + Self::InvalidArgs(_) => { + ::SELECTOR + } Self::InvalidHotShotBlockForCommitmentCheck(_) => { ::SELECTOR - }, + } Self::InvalidInitialization(_) => { ::SELECTOR - }, + } Self::InvalidMaxStateHistory(_) => { ::SELECTOR - }, - Self::InvalidProof(_) => ::SELECTOR, + } + Self::InvalidProof(_) => { + ::SELECTOR + } Self::NoChangeRequired(_) => { ::SELECTOR - }, + } Self::NotInitializing(_) => { ::SELECTOR - }, - Self::OutdatedState(_) => ::SELECTOR, + } + Self::OutdatedState(_) => { + ::SELECTOR + } Self::OwnableInvalidOwner(_) => { ::SELECTOR - }, + } Self::OwnableUnauthorizedAccount(_) => { ::SELECTOR - }, + } Self::ProverNotPermissioned(_) => { ::SELECTOR - }, + } Self::UUPSUnauthorizedCallContext(_) => { ::SELECTOR - }, + } Self::UUPSUnsupportedProxiableUUID(_) => { ::SELECTOR - }, + } Self::WrongStakeTableUsed(_) => { ::SELECTOR - }, + } } } #[inline] @@ -8627,14 +9585,16 @@ pub mod LightClient { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn OutdatedState( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientErrors::OutdatedState) } OutdatedState @@ -8644,7 +9604,10 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientErrors::InvalidProof) } InvalidProof @@ -8655,9 +9618,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::OwnableUnauthorizedAccount) + data, + validate, + ) + .map(LightClientErrors::OwnableUnauthorizedAccount) } OwnableUnauthorizedAccount }, @@ -8667,9 +9631,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::FailedInnerCall) + data, + validate, + ) + .map(LightClientErrors::FailedInnerCall) } FailedInnerCall }, @@ -8679,9 +9644,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::OwnableInvalidOwner) + data, + validate, + ) + .map(LightClientErrors::OwnableInvalidOwner) } OwnableInvalidOwner }, @@ -8691,9 +9657,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::ERC1967InvalidImplementation) + data, + validate, + ) + .map(LightClientErrors::ERC1967InvalidImplementation) } ERC1967InvalidImplementation }, @@ -8703,9 +9670,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::WrongStakeTableUsed) + data, + validate, + ) + .map(LightClientErrors::WrongStakeTableUsed) } WrongStakeTableUsed }, @@ -8730,9 +9698,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::AddressEmptyCode) + data, + validate, + ) + .map(LightClientErrors::AddressEmptyCode) } AddressEmptyCode }, @@ -8741,7 +9710,10 @@ pub mod LightClient { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientErrors::InvalidArgs) } InvalidArgs @@ -8752,9 +9724,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::ProverNotPermissioned) + data, + validate, + ) + .map(LightClientErrors::ProverNotPermissioned) } ProverNotPermissioned }, @@ -8764,9 +9737,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::NoChangeRequired) + data, + validate, + ) + .map(LightClientErrors::NoChangeRequired) } NoChangeRequired }, @@ -8776,9 +9750,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::UUPSUnsupportedProxiableUUID) + data, + validate, + ) + .map(LightClientErrors::UUPSUnsupportedProxiableUUID) } UUPSUnsupportedProxiableUUID }, @@ -8788,9 +9763,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::InsufficientSnapshotHistory) + data, + validate, + ) + .map(LightClientErrors::InsufficientSnapshotHistory) } InsufficientSnapshotHistory }, @@ -8800,9 +9776,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::ERC1967NonPayable) + data, + validate, + ) + .map(LightClientErrors::ERC1967NonPayable) } ERC1967NonPayable }, @@ -8812,9 +9789,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::NotInitializing) + data, + validate, + ) + .map(LightClientErrors::NotInitializing) } NotInitializing }, @@ -8824,9 +9802,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::UUPSUnauthorizedCallContext) + data, + validate, + ) + .map(LightClientErrors::UUPSUnauthorizedCallContext) } UUPSUnauthorizedCallContext }, @@ -8836,9 +9815,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::InvalidAddress) + data, + validate, + ) + .map(LightClientErrors::InvalidAddress) } InvalidAddress }, @@ -8848,9 +9828,10 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::InvalidMaxStateHistory) + data, + validate, + ) + .map(LightClientErrors::InvalidMaxStateHistory) } InvalidMaxStateHistory }, @@ -8860,18 +9841,21 @@ pub mod LightClient { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientErrors::InvalidInitialization) + data, + validate, + ) + .map(LightClientErrors::InvalidInitialization) } InvalidInitialization }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -9127,39 +10111,242 @@ pub mod LightClient { /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 32usize]] = &[ [ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, 212u8, - 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, 133u8, - 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, ], [ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8, - 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8, - 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, ], [ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, ], [ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, 37u8, - 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, 252u8, - 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, ], [ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8, - 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8, - 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, ], [ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, ], [ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8, - 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, ], ]; } @@ -9175,49 +10362,77 @@ pub mod LightClient { match topics.first().copied() { Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::Initialized) - }, + topics, + data, + validate, + ) + .map(Self::Initialized) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::NewState) - }, - Some(::SIGNATURE_HASH) => { + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::OwnershipTransferred) - }, + topics, + data, + validate, + ) + .map(Self::OwnershipTransferred) + } Some( ::SIGNATURE_HASH, - ) => ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverNotRequired), - Some(::SIGNATURE_HASH) => { + ) => { + ::decode_raw_log( + topics, + data, + validate, + ) + .map(Self::PermissionedProverNotRequired) + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverRequired) - }, + topics, + data, + validate, + ) + .map(Self::PermissionedProverRequired) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgrade) - }, + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgraded) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -9227,49 +10442,57 @@ pub mod LightClient { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::NewState(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::NewState(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), - Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::NewState(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::Upgraded(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -9283,9 +10506,9 @@ pub mod LightClient { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -9293,36 +10516,35 @@ pub mod LightClient { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { LightClientInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { LightClientInstance::::deploy_builder(provider) } /**A [`LightClient`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`LightClient`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`LightClient`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct LightClientInstance { address: alloy_sol_types::private::Address, @@ -9333,24 +10555,24 @@ pub mod LightClient { impl ::core::fmt::Debug for LightClientInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightClientInstance") - .field(&self.address) - .finish() + f.debug_tuple("LightClientInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -9359,20 +10581,22 @@ pub mod LightClient { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] - pub async fn deploy(provider: P) -> alloy_contract::Result> { + pub async fn deploy( + provider: P, + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -9415,11 +10639,10 @@ pub mod LightClient { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -9445,8 +10668,16 @@ pub mod LightClient { ///Creates a new call builder for the [`disablePermissionedProverMode`] function. pub fn disablePermissionedProverMode( &self, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&disablePermissionedProverModeCall {}) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + disablePermissionedProverModeCall, + N, + > { + self.call_builder( + &disablePermissionedProverModeCall { + }, + ) } ///Creates a new call builder for the [`finalizedState`] function. pub fn finalizedState( @@ -9461,7 +10692,9 @@ pub mod LightClient { self.call_builder(&genesisStakeTableStateCall {}) } ///Creates a new call builder for the [`genesisState`] function. - pub fn genesisState(&self) -> alloy_contract::SolCallBuilder { + pub fn genesisState( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&genesisStateCall {}) } ///Creates a new call builder for the [`getHotShotCommitment`] function. @@ -9469,7 +10702,11 @@ pub mod LightClient { &self, hotShotBlockHeight: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&getHotShotCommitmentCall { hotShotBlockHeight }) + self.call_builder( + &getHotShotCommitmentCall { + hotShotBlockHeight, + }, + ) } ///Creates a new call builder for the [`getStateHistoryCount`] function. pub fn getStateHistoryCount( @@ -9478,7 +10715,9 @@ pub mod LightClient { self.call_builder(&getStateHistoryCountCall {}) } ///Creates a new call builder for the [`getVersion`] function. - pub fn getVersion(&self) -> alloy_contract::SolCallBuilder { + pub fn getVersion( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&getVersionCall {}) } ///Creates a new call builder for the [`initialize`] function. @@ -9489,12 +10728,14 @@ pub mod LightClient { _stateHistoryRetentionPeriod: u32, owner: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&initializeCall { - _genesis, - _genesisStakeTableState, - _stateHistoryRetentionPeriod, - owner, - }) + self.call_builder( + &initializeCall { + _genesis, + _genesisStakeTableState, + _stateHistoryRetentionPeriod, + owner, + }, + ) } ///Creates a new call builder for the [`isPermissionedProverEnabled`] function. pub fn isPermissionedProverEnabled( @@ -9508,10 +10749,12 @@ pub mod LightClient { blockNumber: alloy::sol_types::private::primitives::aliases::U256, blockThreshold: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&lagOverEscapeHatchThresholdCall { - blockNumber, - blockThreshold, - }) + self.call_builder( + &lagOverEscapeHatchThresholdCall { + blockNumber, + blockThreshold, + }, + ) } ///Creates a new call builder for the [`newFinalizedState`] function. pub fn newFinalizedState( @@ -9519,7 +10762,12 @@ pub mod LightClient { newState: ::RustType, proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&newFinalizedStateCall { newState, proof }) + self.call_builder( + &newFinalizedStateCall { + newState, + proof, + }, + ) } ///Creates a new call builder for the [`owner`] function. pub fn owner(&self) -> alloy_contract::SolCallBuilder { @@ -9532,7 +10780,9 @@ pub mod LightClient { self.call_builder(&permissionedProverCall {}) } ///Creates a new call builder for the [`proxiableUUID`] function. - pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder { + pub fn proxiableUUID( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&proxiableUUIDCall {}) } ///Creates a new call builder for the [`renounceOwnership`] function. @@ -9546,14 +10796,27 @@ pub mod LightClient { &self, prover: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setPermissionedProverCall { prover }) + self.call_builder( + &setPermissionedProverCall { + prover, + }, + ) } ///Creates a new call builder for the [`setstateHistoryRetentionPeriod`] function. pub fn setstateHistoryRetentionPeriod( &self, historySeconds: u32, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setstateHistoryRetentionPeriodCall { historySeconds }) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + setstateHistoryRetentionPeriodCall, + N, + > { + self.call_builder( + &setstateHistoryRetentionPeriodCall { + historySeconds, + }, + ) } ///Creates a new call builder for the [`stateHistoryCommitments`] function. pub fn stateHistoryCommitments( @@ -9587,20 +10850,21 @@ pub mod LightClient { newImplementation: alloy::sol_types::private::Address, data: alloy::sol_types::private::Bytes, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&upgradeToAndCallCall { - newImplementation, - data, - }) + self.call_builder( + &upgradeToAndCallCall { + newImplementation, + data, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -9611,7 +10875,9 @@ pub mod LightClient { alloy_contract::Event::new_sol(&self.provider, &self.address) } ///Creates a new event filter for the [`Initialized`] event. - pub fn Initialized_filter(&self) -> alloy_contract::Event { + pub fn Initialized_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } ///Creates a new event filter for the [`NewState`] event. diff --git a/contract-bindings-alloy/src/lightclientarbitrum.rs b/contract-bindings-alloy/src/lightclientarbitrum.rs index 105a3c7d38..f68b7a21d1 100644 --- a/contract-bindings-alloy/src/lightclientarbitrum.rs +++ b/contract-bindings-alloy/src/lightclientarbitrum.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -563,12 +620,11 @@ library IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -681,11 +737,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -764,23 +822,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -791,50 +871,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -848,111 +942,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) + .0, + ::eip712_data_word( + &self.wire3, + ) + .0, + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) + .0, + ::eip712_data_word( + &self.split1, + ) + .0, + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1035,7 +1231,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1081,7 +1279,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1129,17 +1328,24 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1153,15 +1359,15 @@ pub mod IPlonkVerifier { } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -1172,24 +1378,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1231,11 +1437,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -1250,11 +1455,10 @@ pub mod IPlonkVerifier { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -1283,12 +1487,11 @@ library LightClient { clippy::empty_structs_with_brackets )] pub mod LightClient { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } - ```*/ +struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct LightClientState { @@ -1321,11 +1524,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1355,13 +1560,15 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.viewNum, - ), - as alloy_sol_types::SolType>::tokenize( - &self.blockHeight, + as alloy_sol_types::SolType>::tokenize(&self.viewNum), + as alloy_sol_types::SolType>::tokenize(&self.blockHeight), + ::tokenize( + &self.blockCommRoot, ), - ::tokenize(&self.blockCommRoot), ) } #[inline] @@ -1369,50 +1576,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for LightClientState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1426,9 +1647,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -1478,7 +1699,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1497,16 +1720,23 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } - ```*/ +struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StakeTableState { @@ -1543,11 +1773,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1583,14 +1815,18 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.threshold, + as alloy_sol_types::SolType>::tokenize(&self.threshold), + ::tokenize( + &self.blsKeyComm, ), - ::tokenize(&self.blsKeyComm), ::tokenize( &self.schnorrKeyComm, ), - ::tokenize(&self.amountComm), + ::tokenize( + &self.amountComm, + ), ) } #[inline] @@ -1598,50 +1834,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for StakeTableState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1655,9 +1905,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -1712,7 +1962,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1733,17 +1985,24 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1757,15 +2016,15 @@ pub mod LightClient { } /**A [`LightClient`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`LightClient`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`LightClient`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct LightClientInstance { address: alloy_sol_types::private::Address, @@ -1776,24 +2035,24 @@ pub mod LightClient { impl ::core::fmt::Debug for LightClientInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightClientInstance") - .field(&self.address) - .finish() + f.debug_tuple("LightClientInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1835,12 +2094,11 @@ pub mod LightClient { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { - /// Creates a new call builder using this contract instance's provider and address. + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { + /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this /// contract. Prefer using the other methods for building type-safe contract calls. @@ -1854,11 +2112,10 @@ pub mod LightClient { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -2969,9 +3226,8 @@ interface LightClientArbitrum { clippy::empty_structs_with_brackets )] pub mod LightClientArbitrum { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -2993,9 +3249,9 @@ pub mod LightClientArbitrum { b"`\x80`@R`\x046\x10a\x01GW_5`\xE0\x1C\x80c\x82nA\xFC\x11a\0\xB3W\x80c\xAD<\xB1\xCC\x11a\0mW\x80c\xAD<\xB1\xCC\x14a\x04pW\x80c\xC2;\x9E\x9E\x14a\x04\xADW\x80c\xD2M\x93=\x14a\x04\xE5W\x80c\xE003\x01\x14a\x05\x14W\x80c\xF2\xFD\xE3\x8B\x14a\x053W\x80c\xF9\xE5\r\x19\x14a\x05RW_\x80\xFD[\x80c\x82nA\xFC\x14a\x03:W\x80c\x85\x84\xD2?\x14a\x03eW\x80c\x8D\xA5\xCB[\x14a\x03\xA1W\x80c\x96\xC1\xCAa\x14a\x03\xDDW\x80c\x9B\xAA<\xC9\x14a\x03\xFCW\x80c\x9F\xDBT\xA7\x14a\x04\x1BW_\x80\xFD[\x80c7\x8E\xC2;\x11a\x01\x04W\x80c7\x8E\xC2;\x14a\x02\x88W\x80cBm1\x94\x14a\x02\xAAW\x80cO\x1E\xF2\x86\x14a\x02\xEBW\x80cR\xD1\x90-\x14a\x02\xFEW\x80ci\xCCj\x04\x14a\x03\x12W\x80cqP\x18\xA6\x14a\x03&W_\x80\xFD[\x80c\x01?\xA5\xFC\x14a\x01KW\x80c\x02\xB5\x92\xF3\x14a\x01lW\x80c\r\x8En,\x14a\x01\xC9W\x80c c\xD4\xF7\x14a\x01\xF4W\x80c/y\x88\x9D\x14a\x02\x13W\x80c1=\xF7\xB1\x14a\x02QW[_\x80\xFD[4\x80\x15a\x01VW_\x80\xFD[Pa\x01ja\x01e6`\x04a\x1F\x92V[a\x05fV[\0[4\x80\x15a\x01wW_\x80\xFD[Pa\x01\x8Ba\x01\x866`\x04a\x1F\xABV[a\x06\x19V[`@Qa\x01\xC0\x94\x93\x92\x91\x90`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x84\x01R\x92\x16`@\x82\x01R``\x81\x01\x91\x90\x91R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x01\xD4W_\x80\xFD[P`@\x80Q`\x01\x81R_` \x82\x01\x81\x90R\x91\x81\x01\x91\x90\x91R``\x01a\x01\xC0V[4\x80\x15a\x01\xFFW_\x80\xFD[Pa\x01ja\x02\x0E6`\x04a \xF6V[a\x06bV[4\x80\x15a\x02\x1EW_\x80\xFD[P`\x08Ta\x029\x90`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x81V[`@Q`\x01`\x01`@\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\\W_\x80\xFD[P`\x08Ta\x02p\x90`\x01`\x01`\xA0\x1B\x03\x16\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\x93W_\x80\xFD[Pa\x02\x9Ca\x07\xBDV[`@Q\x90\x81R` \x01a\x01\xC0V[4\x80\x15a\x02\xB5W_\x80\xFD[P_T`\x01T`\x02T`\x03Ta\x02\xCB\x93\x92\x91\x90\x84V[`@\x80Q\x94\x85R` \x85\x01\x93\x90\x93R\x91\x83\x01R``\x82\x01R`\x80\x01a\x01\xC0V[a\x01ja\x02\xF96`\x04a\"\xA7V[a\x08$V[4\x80\x15a\x03\tW_\x80\xFD[Pa\x02\x9Ca\x08CV[4\x80\x15a\x03\x1DW_\x80\xFD[Pa\x01ja\x08^V[4\x80\x15a\x031W_\x80\xFD[Pa\x01ja\x08\xCCV[4\x80\x15a\x03EW_\x80\xFD[P`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15\x15[`@Q\x90\x15\x15\x81R` \x01a\x01\xC0V[4\x80\x15a\x03pW_\x80\xFD[Pa\x03\x84a\x03\x7F6`\x04a\x1F\xABV[a\x08\xDDV[`@\x80Q\x92\x83R`\x01`\x01`@\x1B\x03\x90\x91\x16` \x83\x01R\x01a\x01\xC0V[4\x80\x15a\x03\xACW_\x80\xFD[P\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16a\x02pV[4\x80\x15a\x03\xE8W_\x80\xFD[Pa\x01ja\x03\xF76`\x04a#YV[a\n\x08V[4\x80\x15a\x04\x07W_\x80\xFD[Pa\x01ja\x04\x166`\x04a#rV[a\n\x91V[4\x80\x15a\x04&W_\x80\xFD[P`\x06T`\x07Ta\x04J\x91`\x01`\x01`@\x1B\x03\x80\x82\x16\x92`\x01`@\x1B\x90\x92\x04\x16\x90\x83V[`@\x80Q`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x93\x90\x92\x16` \x84\x01R\x90\x82\x01R``\x01a\x01\xC0V[4\x80\x15a\x04{W_\x80\xFD[Pa\x04\xA0`@Q\x80`@\x01`@R\x80`\x05\x81R` \x01d\x03R\xE3\x02\xE3`\xDC\x1B\x81RP\x81V[`@Qa\x01\xC0\x91\x90a$=V[4\x80\x15a\x04\xB8W_\x80\xFD[P`\x08Ta\x04\xD0\x90`\x01`\xA0\x1B\x90\x04c\xFF\xFF\xFF\xFF\x16\x81V[`@Qc\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01a\x01\xC0V[4\x80\x15a\x04\xF0W_\x80\xFD[P`\x04T`\x05Ta\x04J\x91`\x01`\x01`@\x1B\x03\x80\x82\x16\x92`\x01`@\x1B\x90\x92\x04\x16\x90\x83V[4\x80\x15a\x05\x1FW_\x80\xFD[Pa\x03Ua\x05.6`\x04a$oV[a\x0B\xB3V[4\x80\x15a\x05>W_\x80\xFD[Pa\x01ja\x05M6`\x04a\x1F\x92V[a\r\x14V[4\x80\x15a\x05]W_\x80\xFD[P`\tTa\x02\x9CV[a\x05na\rVV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x05\x95W`@Qc\xE6\xC4${`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x82\x16\x03a\x05\xC4W`@Qc\xA8c\xAE\xC9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x80\x17\xBB\x88\x7F\xDF\x8F\xCAC\x14\xA9\xD4\x0Fns\xB3\xB8\x10\x02\xD6~\\\xFA\x85\xD8\x81s\xAFj\xA4`r\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[`\t\x81\x81T\x81\x10a\x06(W_\x80\xFD[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01\x80T`\x01\x90\x91\x01T`\x01`\x01`@\x1B\x03\x80\x83\x16\x93P`\x01`@\x1B\x83\x04\x81\x16\x92`\x01`\x80\x1B\x90\x04\x16\x90\x84V[`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x80\x15a\x06\x87WP`\x08T`\x01`\x01`\xA0\x1B\x03\x163\x14\x15[\x15a\x06\xA5W`@Qc\x01GL\x8F`\xE7\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x06T\x82Q`\x01`\x01`@\x1B\x03\x91\x82\x16\x91\x16\x11\x15\x80a\x06\xDEWP`\x06T` \x83\x01Q`\x01`\x01`@\x1B\x03`\x01`@\x1B\x90\x92\x04\x82\x16\x91\x16\x11\x15[\x15a\x06\xFCW`@Qc\x05\x1CF\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x07\t\x82`@\x01Qa\r\xB1V[a\x07\x13\x82\x82a\x0E!V[\x81Q`\x06\x80T` \x85\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x92\x16\x93\x16\x92\x90\x92\x17\x91\x90\x91\x17\x90U`@\x82\x01Q`\x07Ua\x07aa\x07Za\x07\xBDV[B\x84a\x0F\x15V[\x81` \x01Q`\x01`\x01`@\x1B\x03\x16\x82_\x01Q`\x01`\x01`@\x1B\x03\x16\x7F\xA0Jw9$PZA\x85d67%\xF5h2\xF5w.k\x8D\r\xBDn\xFC\xE7$\xDF\xE8\x03\xDA\xE6\x84`@\x01Q`@Qa\x07\xB1\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPV[_`d`\x01`\x01`\xA0\x1B\x03\x16c\xA3\xB1\xB3\x1D`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x15\x80\x15a\x07\xFBW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x08\x1F\x91\x90a$\x8FV[\x90P\x90V[a\x08,a\x10\xFEV[a\x085\x82a\x11\xA2V[a\x08?\x82\x82a\x11\xE3V[PPV[_a\x08La\x12\xA4V[P_\x80Q` a)\xB1\x839\x81Q\x91R\x90V[a\x08fa\rVV[`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15a\x08\xB1W`\x08\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U`@Q\x7F\x9A_W\xDE\x85m\xD6h\xC5M\xD9^\\U\xDF\x93C!q\xCB\xCAI\xA8wmV \xEAY\xC0$P\x90_\x90\xA1V[`@Qc\xA8c\xAE\xC9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[a\x08\xD4a\rVV[a\x08\xCA_a\x12\xEDV[`\t\x80T_\x91\x82\x91\x90a\x08\xF1`\x01\x83a$\xBAV[\x81T\x81\x10a\t\x01Wa\t\x01a$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x80\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x84\x10a\t@W`@Qc\x18V\xA4\x99`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16[\x81\x81\x10\x15a\n\x01W\x84`\t\x82\x81T\x81\x10a\tpWa\tpa$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x80\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x11\x15a\t\xF9W`\t\x81\x81T\x81\x10a\t\xA9Wa\t\xA9a$\xCDV[\x90_R` _ \x90`\x02\x02\x01`\x01\x01T`\t\x82\x81T\x81\x10a\t\xCCWa\t\xCCa$\xCDV[\x90_R` _ \x90`\x02\x02\x01_\x01`\x10\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`@\x1B\x03\x16\x93P\x93PPP\x91P\x91V[`\x01\x01a\tTV[PP\x91P\x91V[a\n\x10a\rVV[a\x0E\x10\x81c\xFF\xFF\xFF\xFF\x16\x10\x80a\n/WPc\x01\xE13\x80\x81c\xFF\xFF\xFF\xFF\x16\x11[\x80a\nMWP`\x08Tc\xFF\xFF\xFF\xFF`\x01`\xA0\x1B\x90\x91\x04\x81\x16\x90\x82\x16\x11\x15[\x15a\nkW`@Qc\x07\xA5\x07w`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08\x80Tc\xFF\xFF\xFF\xFF\x90\x92\x16`\x01`\xA0\x1B\x02c\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90`\x01`\x01`@\x1B\x03\x16_\x81\x15\x80\x15a\n\xD5WP\x82[\x90P_\x82`\x01`\x01`@\x1B\x03\x16`\x01\x14\x80\x15a\n\xF0WP0;\x15[\x90P\x81\x15\x80\x15a\n\xFEWP\x80\x15[\x15a\x0B\x1CW`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x0BFW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0BO\x86a\x13]V[a\x0BWa\x13nV[a\x0Bb\x89\x89\x89a\x13vV[\x83\x15a\x0B\xA8W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPV[`\tT_\x90a\x0B\xC0a\x07\xBDV[\x84\x11\x80a\x0B\xCBWP\x80\x15[\x80a\x0C\x15WP`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0B\xF9Wa\x0B\xF9a$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x84\x10[\x15a\x0C3W`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80a\x0CA`\x01\x85a$\xBAV[\x90P[\x81a\x0C\xDDW`\x08T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x81\x10a\x0C\xDDW\x86`\t\x82\x81T\x81\x10a\x0CvWa\x0Cva$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x11a\x0C\xCBW`\x01\x91P`\t\x81\x81T\x81\x10a\x0C\xABWa\x0C\xABa$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x92Pa\x0C\xDDV[\x80a\x0C\xD5\x81a$\xE1V[\x91PPa\x0CDV[\x81a\x0C\xFBW`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85a\r\x06\x84\x89a$\xBAV[\x11\x94PPPPP[\x92\x91PPV[a\r\x1Ca\rVV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\rJW`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\rS\x81a\x12\xEDV[PV[3a\r\x88\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\x08\xCAW`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\rAV[\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x81\x10\x80a\x08?W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FBn254: invalid scalar field\0\0\0\0\0`D\x82\x01R`d\x01a\rAV[_a\x0E*a\x14\xA2V[\x90Pa\x0E4a\x1C\xF3V[\x83Q`\x01`\x01`@\x1B\x03\x90\x81\x16\x82R` \x85\x01Q\x16\x81`\x01` \x02\x01R`@\x84\x81\x01Q\x82\x82\x01R`\x01T``\x83\x01R`\x02T`\x80\x83\x01R`\x03T`\xA0\x83\x01R_T`\xC0\x83\x01RQc\xCESzw`\xE0\x1B\x81Rs_\xBD\xB21Vx\xAF\xEC\xB3g\xF02\xD9?d/d\x18\n\xA3\x90c\xCESzw\x90a\x0E\xB3\x90\x85\x90\x85\x90\x88\x90`\x04\x01a&\xFCV[` `@Q\x80\x83\x03\x81\x86Z\xF4\x15\x80\x15a\x0E\xCEW=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0E\xF2\x91\x90a)*V[a\x0F\x0FW`@Qc\t\xBD\xE39`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\tT\x15\x80\x15\x90a\x0F\x8AWP`\x08T`\t\x80T`\x01`\xA0\x1B\x83\x04c\xFF\xFF\xFF\xFF\x16\x92`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0FUWa\x0FUa$\xCDV[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01Ta\x0F\x7F\x90`\x01`@\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x84a)IV[`\x01`\x01`@\x1B\x03\x16\x11[\x15a\x10\x1DW`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0F\xB7Wa\x0F\xB7a$\xCDV[_\x91\x82R` \x82 `\x02\x90\x91\x02\x01\x80T`\x01`\x01`\xC0\x1B\x03\x19\x16\x81U`\x01\x01U`\x08\x80T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90`\x18a\x0F\xF7\x83a)pV[\x91\x90a\x01\0\n\x81T\x81`\x01`\x01`@\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`@\x1B\x03\x16\x02\x17\x90UPP[`@\x80Q`\x80\x81\x01\x82R`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x80\x85\x01\x91\x82R\x83\x01Q\x85\x16\x84\x83\x01\x90\x81R\x92\x90\x91\x01Q``\x84\x01\x90\x81R`\t\x80T`\x01\x81\x01\x82U_\x91\x90\x91R\x93Q`\x02\x90\x94\x02\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xAF\x81\x01\x80T\x93Q\x94Q\x87\x16`\x01`\x80\x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x80\x1B\x19\x95\x88\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x95\x16\x96\x90\x97\x16\x95\x90\x95\x17\x92\x90\x92\x17\x92\x90\x92\x16\x93\x90\x93\x17\x90\x91UQ\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xB0\x90\x91\x01UV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x11\x84WP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16a\x11x_\x80Q` a)\xB1\x839\x81Q\x91RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\x08\xCAW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11\xAAa\rVV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01a\x06\x0EV[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x12=WP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x12:\x91\x81\x01\x90a$\x8FV[`\x01[a\x12eW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\rAV[_\x80Q` a)\xB1\x839\x81Q\x91R\x81\x14a\x12\x95W`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\rAV[a\x12\x9F\x83\x83a\x1A\xD1V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x08\xCAW`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\x13ea\x1B&V[a\rS\x81a\x1BoV[a\x08\xCAa\x1B&V[\x82Q`\x01`\x01`@\x1B\x03\x16\x15\x15\x80a\x13\x9AWP` \x83\x01Q`\x01`\x01`@\x1B\x03\x16\x15\x15[\x80a\x13\xA7WP` \x82\x01Q\x15[\x80a\x13\xB4WP`@\x82\x01Q\x15[\x80a\x13\xC1WP``\x82\x01Q\x15[\x80a\x13\xCBWP\x81Q\x15[\x80a\x13\xDDWPa\x0E\x10\x81c\xFF\xFF\xFF\xFF\x16\x10[\x80a\x13\xF1WPc\x01\xE13\x80\x81c\xFF\xFF\xFF\xFF\x16\x11[\x15a\x14\x0FW`@QcP\xDD\x03\xF7`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82Q`\x04\x80T` \x80\x87\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x93\x84\x16\x91\x90\x95\x16\x90\x81\x17\x85\x17\x90\x93U`@\x96\x87\x01Q`\x05\x81\x90U\x86Q_U\x90\x86\x01Q`\x01U\x95\x85\x01Q`\x02U``\x90\x94\x01Q`\x03U`\x06\x80T\x90\x94\x16\x17\x17\x90\x91U`\x07\x91\x90\x91U`\x08\x80Tc\xFF\xFF\xFF\xFF\x90\x92\x16`\x01`\xA0\x1B\x02c\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[a\x14\xAAa\x1D\x11V[b\x10\0\0\x81R`\x07` \x82\x01R\x7F#x=\x0E\x97w\xB7\xAFe\xFB\xF8I\xDA~\xDBu\xE7K\x1E\xAFP>\x02]\x7F/\x7F\x80\x99\x1B\xEF\xA2`@\x82\x01QR\x7F*N/\xE8\xAD\xFAS\xF4hRU\x82\xD5\x18LLp\xBB\xDB\x94l!\xF2\x16A\x8A\x98yp^T\xA7` `@\x83\x01Q\x01R\x7F\x06$\xB2\xC1\xE7\x7F$\xAF\xCE\xAF9E\x17C\xB9\xFA\x80\xD5\x85?\xCA{\xA0\x03\x89\xC6ue\x07t\0\x9B``\x82\x01QR\x7F%\rw\x19\xE9L\xA2\xDF\0\xDF\xE3'\x93\x8FZ\x8DM\x83wy\xB9\x987\xCAwzS\xD3\x91'\xB1y` ``\x83\x01Q\x01R\x7F\r\xC0\x95\x15\x15.\xAE\xA6m\r\xB2\xF5q\xCC\x99^6\x9D&\xFEds\x94\xF1\r\xB59\x8C\x91u\x19\xDC`\x80\x82\x01QR\x7F\x12s\x14Ml\xEC,Jh\xB2J\x14\x93y\xC0\xF5Y+\xB7\xFB\xDD\xBE2\xFA\x17\x19\x19\x95\x0C\xA4\x04\xCB` `\x80\x83\x01Q\x01R\x7F\x11\x95!\xBBh\xCA\xEC!n/\x05\xEE\xB4f\xFB:\xBF\xE1\xF3\x9B\xAF\x7F\xE7\xCB9.\xA0W\xB6\xA2\xD9\xBF`\xA0\x82\x01QR\x7F-R\xAD\xEA\xBA\x80E\xE5:\xB5&\xFE\x99\x82\xD0\xEAE-\xEFk>\xA0%='\xA1\x9E\xF3\xB4n\x84(` `\xA0\x83\x01Q\x01R\x7F\x16\xC3\xB5\xB2\x17\xD3\x02\x97Z\x92\r\x137E$\xD7\xA5.JP\xFD\x7F\xB90\x84\"q\xEB\xF4\xA8N\xFD`\xC0\x82\x01QR\x7F \x07\x88\x91k\x90{\x19ir\xBD\xE3\x041\x8E\x88Z%!QK-\xB5\xE4\xA1\x18\x99\xC5\x12\x04\xF0\x89` `\xC0\x83\x01Q\x01R\x7F\x11'X\x1A\xFEu=\xEF\xCA\x9A\xEF\x12\xE73-\xB9\x97\x8A \x0B\x16\x99\xCE8\x88\xC0\xF3\xAE\xA6\x11\x1D\xC3`\xE0\x82\x01QR\x7F\x08\x81\xE1?\0r;\xE1\xA0Hr\xED\x02\xB2\xD0x\xC3\x1E\x80\xFE\xAF'rN&,\xE9|,\xB0\xBB\x1D` `\xE0\x83\x01Q\x01R\x7F\x14\x82\xA3\xA6\xBB\x91\xD6H=\x156\x83\xE2@O/UF\xE0\xE8\x95S\x0F\xDF\x13 \x91I\x84\x06\xE3\xDEa\x01\0\x82\x01QR~\xFAR\xDB=R\xD9\x05\xEA\xD1$\x81\x02\xF3\xA8\nC\xA9\r\x84\0\xC6\x8F`\xA6,T\xC7\x18u\xD8\xDD\xC3UFXd\x0C\xC9U\x01a\x01\xC0\x82\x01QR\x7F$:\x99\xD8\r2\xEBT\x08\xB5\x9D[\x080+\xED\xE0p\xD3\xFB\n\x8E\xFE/\"b\xF8e\xBF\xFBM\r` a\x01\xC0\x83\x01Q\x01R\x7F\x04U\xD22[\xF6&\x9Af\xF0}\x83\x8FU\xF3iG\xA3\xCD\x9B\x87\xED\xD8H\x0B\xCE\xD9\\\xBBE\xCC\x11a\x01\xE0\x82\x01QR\x7F\x0Ff\xD9\x08Zn\xD6\x0B\x83\x81y\x98~$\t\x92\xBF\xF4\xC0Ql\xCFl\xCD\xE4\xA1\xCA\x94\xCE\x8B\x98d` a\x01\xE0\x83\x01Q\x01R\x7F+\xAC\r#\xC8X]\x14\x87\xECa\x1B^\xFF\xC9~XR\xFE\xA4:|\xBA6\xCC\xDD, y1\xF3\x94a\x02\0\x82\x01QR\x7F\x18`\xB5N\x01\xA0j\xEAZ\xDBK\x13\xBF[\xAE\xBA\xB9+sh\x07\xA3\xA8\x9F\xF2\x04\t\x92\xB0n\xE6\xEC` a\x02\0\x83\x01Q\x01R\x7F\x0C\x0B\xFA\x1C/\xC6\xF8\xED\x01#=Qh\xDB\x1E\x1D\xFErU\x04\xF02\xF6i\xF5\n\x92\xAEw\xC7)\x06a\x02 \x82\x01QR\x7F\rt\x1E\x12L}\x10i\xB8\xA4\0\xCB\xCD\xCF\xD9\x01(\xA53\x90\x1A\xD4\xDE\x1E\x03\x7F\xE7)\x84\xDC4\xCF` a\x02 \x83\x01Q\x01R\x7F\x01\xCF\xED0\x08\\\x9E\xFC\xE0Fh W\x94\xAA9\xB1\xA8\xEEY\x124\xB4\xC7z\"\xF8\xC2m\x89\x9E\x05a\x02@\x82\x01QR\x7F*\xB6\x8A\xC8-6\xCE\xDBd}\x14\xA5\xB0\x03^\x8C\x9A\x0B\xE8G\x80\xB7\xBA\xE1\x13:'\xA8\x80\x96n\xD1` a\x02@\x83\x01Q\x01R\x7F\x07.\x1DP\xF8\xB5\xCF\x8DWK8G'dw\xD9[\xBDQ\x165\x10\0\x84\x1Fr\x8D\xA4O@C\xB5a\x02`\x82\x01QR\x7F#\xF8\xEAn\xAC\xD0\x87mW\"\x0FW\xEA\xBA\xCB\xE7j##A\x16cs\x1A%\x1D]\xCA6\xF1\xB5\x9F` a\x02`\x83\x01Q\x01R\x7F\xB0\x83\x88\x93\xEC\x1F#~\x8B\x072;\x07DY\x9FN\x97\xB5\x98\xB3\xB5\x89\xBC\xC2\xBC7\xB8\xD5\xC4\x18\x01a\x02\x80\x82\x01R\x7F\xC1\x83\x93\xC0\xFA0\xFEN\x8B\x03\x8E5z\xD8Q\xEA\xE8\xDE\x91\x07XN\xFF\xE7\xC7\xF1\xF6Q\xB2\x01\x0E&a\x02\xA0\x82\x01R\x90V[a\x1A\xDA\x82a\x1BwV[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x1B\x1EWa\x12\x9F\x82\x82a\x1B\xDAV[a\x08?a\x1CLV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\x08\xCAW`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\r\x1Ca\x1B&V[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1B\xACW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\rAV[_\x80Q` a)\xB1\x839\x81Q\x91R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``_\x80\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x1B\xF6\x91\x90a)\x95V[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1C.W`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1C3V[``\x91P[P\x91P\x91Pa\x1CC\x85\x83\x83a\x1CkV[\x95\x94PPPPPV[4\x15a\x08\xCAW`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x1C\x80Wa\x1C{\x82a\x1C\xCAV[a\x1C\xC3V[\x81Q\x15\x80\x15a\x1C\x97WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x1C\xC0W`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\rAV[P\x80[\x93\x92PPPV[\x80Q\x15a\x1C\xDAW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q\x80`\xE0\x01`@R\x80`\x07\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[`@Q\x80a\x02\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01a\x1DD`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Dd`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\x84`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xA4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xC4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1D\xE4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\x04`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E$`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1ED`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Ed`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\x84`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xA4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xC4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1E\xE4`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\x04`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F$`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1FD`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Fd`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x90\x91\x01R\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x1F\x8DW_\x80\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a\x1F\xA2W_\x80\xFD[a\x1C\xC3\x82a\x1FwV[_` \x82\x84\x03\x12\x15a\x1F\xBBW_\x80\xFD[P5\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Qa\x02\xE0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x1F\xF9Wa\x1F\xF9a\x1F\xC2V[`@R\x90V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a 'Wa 'a\x1F\xC2V[`@R\x91\x90PV[\x805`\x01`\x01`@\x1B\x03\x81\x16\x81\x14a\x1F\x8DW_\x80\xFD[_``\x82\x84\x03\x12\x15a UW_\x80\xFD[`@Q``\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a wWa wa\x1F\xC2V[`@R\x90P\x80a \x86\x83a /V[\x81Ra \x94` \x84\x01a /V[` \x82\x01R`@\x83\x015`@\x82\x01RP\x92\x91PPV[_`@\x82\x84\x03\x12\x15a \xBAW_\x80\xFD[`@Q`@\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a \xDCWa \xDCa\x1F\xC2V[`@R\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x80\x82\x84\x03a\x04\xE0\x81\x12\x15a!\tW_\x80\xFD[a!\x13\x85\x85a EV[\x92Pa\x04\x80\x80`_\x19\x83\x01\x12\x15a!(W_\x80\xFD[a!0a\x1F\xD6V[\x91Pa!?\x86``\x87\x01a \xAAV[\x82Ra!N\x86`\xA0\x87\x01a \xAAV[` \x83\x01Ra!`\x86`\xE0\x87\x01a \xAAV[`@\x83\x01Ra\x01 a!t\x87\x82\x88\x01a \xAAV[``\x84\x01Ra\x01`a!\x88\x88\x82\x89\x01a \xAAV[`\x80\x85\x01Ra\x01\xA0a!\x9C\x89\x82\x8A\x01a \xAAV[`\xA0\x86\x01Ra\x01\xE0a!\xB0\x8A\x82\x8B\x01a \xAAV[`\xC0\x87\x01Ra\x02 a!\xC4\x8B\x82\x8C\x01a \xAAV[`\xE0\x88\x01Ra\x02`a!\xD8\x8C\x82\x8D\x01a \xAAV[a\x01\0\x89\x01Ra\x02\xA0a!\xED\x8D\x82\x8E\x01a \xAAV[\x87\x8A\x01Ra!\xFF\x8Da\x02\xE0\x8E\x01a \xAAV[a\x01@\x8A\x01Ra\"\x13\x8Da\x03 \x8E\x01a \xAAV[\x86\x8A\x01Ra\"%\x8Da\x03`\x8E\x01a \xAAV[a\x01\x80\x8A\x01Ra\x03\xA0\x8C\x015\x94\x89\x01\x94\x90\x94Ra\x03\xC0\x8B\x015a\x01\xC0\x89\x01Ra\x03\xE0\x8B\x015\x92\x88\x01\x92\x90\x92Ra\x04\0\x8A\x015a\x02\0\x88\x01Ra\x04 \x8A\x015\x90\x87\x01Ra\x04@\x89\x015a\x02@\x87\x01Ra\x04`\x89\x015\x90\x86\x01R\x92\x87\x015a\x02\x80\x85\x01RPPa\x04\xA0\x85\x015\x90\x82\x01Ra\x04\xC0\x90\x93\x015a\x02\xC0\x84\x01RP\x92\x90\x91PV[_\x80`@\x83\x85\x03\x12\x15a\"\xB8W_\x80\xFD[a\"\xC1\x83a\x1FwV[\x91P` \x80\x84\x015`\x01`\x01`@\x1B\x03\x80\x82\x11\x15a\"\xDDW_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a\"\xF0W_\x80\xFD[\x815\x81\x81\x11\x15a#\x02Wa#\x02a\x1F\xC2V[a#\x14`\x1F\x82\x01`\x1F\x19\x16\x85\x01a\x1F\xFFV[\x91P\x80\x82R\x87\x84\x82\x85\x01\x01\x11\x15a#)W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80\x93PPPP\x92P\x92\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x1F\x8DW_\x80\xFD[_` \x82\x84\x03\x12\x15a#iW_\x80\xFD[a\x1C\xC3\x82a#FV[_\x80_\x80\x84\x86\x03a\x01 \x81\x12\x15a#\x87W_\x80\xFD[a#\x91\x87\x87a EV[\x94P`\x80`_\x19\x82\x01\x12\x15a#\xA4W_\x80\xFD[P`@Q`\x80\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a#\xC7Wa#\xC7a\x1F\xC2V[\x80`@RP``\x86\x015\x81R`\x80\x86\x015` \x82\x01R`\xA0\x86\x015`@\x82\x01R`\xC0\x86\x015``\x82\x01R\x80\x93PPa$\x01`\xE0\x86\x01a#FV[\x91Pa$\x10a\x01\0\x86\x01a\x1FwV[\x90P\x92\x95\x91\x94P\x92PV[_[\x83\x81\x10\x15a$5W\x81\x81\x01Q\x83\x82\x01R` \x01a$\x1DV[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra$[\x81`@\x85\x01` \x87\x01a$\x1BV[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_\x80`@\x83\x85\x03\x12\x15a$\x80W_\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x82\x84\x03\x12\x15a$\x9FW_\x80\xFD[PQ\x91\x90PV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\r\x0EWa\r\x0Ea$\xA6V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[_\x81a$\xEFWa$\xEFa$\xA6V[P_\x19\x01\x90V[\x80_[`\x07\x81\x10\x15a\x0F\x0FW\x81Q\x84R` \x93\x84\x01\x93\x90\x91\x01\x90`\x01\x01a$\xF9V[a%-\x82\x82Q\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[` \x81\x81\x01Q\x80Q`@\x85\x01R\x90\x81\x01Q``\x84\x01RP`@\x81\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP``\x81\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\x80\x81\x01Qa\x01\0a%\x90\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xA0\x83\x01Q\x91Pa\x01@a%\xB0\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x84\x01Q\x92Pa\x01\x80a%\xD0\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x85\x01Q\x93Pa\x01\xC0a%\xF0\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x85\x01Q\x93Pa\x02\0\x92a&\x10\x87\x85\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x86\x01Q\x94Pa\x02@a&1\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x86\x01Q\x94Pa\x02\x80\x92a&Q\x88\x85\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x87\x01Q\x95Pa\x02\xC0a&r\x81\x8A\x01\x88\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x87\x01Q\x80Qa\x03\0\x8A\x01R` \x01Qa\x03 \x89\x01Ra\x01\xA0\x87\x01Qa\x03@\x89\x01R\x90\x86\x01Qa\x03`\x88\x01Ra\x01\xE0\x86\x01Qa\x03\x80\x88\x01R\x92\x85\x01Qa\x03\xA0\x87\x01Ra\x02 \x85\x01Qa\x03\xC0\x87\x01R\x91\x84\x01Qa\x03\xE0\x86\x01Ra\x02`\x84\x01Qa\x04\0\x86\x01R\x83\x01Qa\x04 \x85\x01Ra\x02\xA0\x83\x01Qa\x04@\x85\x01R\x90\x91\x01Qa\x04`\x90\x92\x01\x91\x90\x91RPV[_a\n`\x82\x01\x90P\x84Q\x82R` \x85\x01Q` \x83\x01R`@\x85\x01Qa'.`@\x84\x01\x82\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[P``\x85\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP`\x80\x85\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\xA0\x85\x01Qa\x01\0a'{\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x87\x01Q\x91Pa\x01@a'\x9B\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x88\x01Q\x92Pa\x01\x80a'\xBB\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x88\x01Q\x92Pa\x01\xC0\x91a'\xDB\x86\x84\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x89\x01Q\x93Pa\x02\0a'\xFC\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x89\x01Q\x93Pa\x02@\x91a(\x1C\x87\x84\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x8A\x01Q\x94Pa\x02\x80a(=\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x8A\x01Q\x80Qa\x02\xC0\x89\x01R` \x90\x81\x01Qa\x02\xE0\x89\x01Ra\x01\xA0\x8B\x01Q\x80Qa\x03\0\x8A\x01R\x81\x01Qa\x03 \x89\x01R\x93\x8A\x01Q\x80Qa\x03@\x89\x01R\x84\x01Qa\x03`\x88\x01Ra\x01\xE0\x8A\x01Q\x80Qa\x03\x80\x89\x01R\x84\x01Qa\x03\xA0\x88\x01R\x89\x01Q\x80Qa\x03\xC0\x88\x01R\x83\x01Qa\x03\xE0\x87\x01Ra\x02 \x89\x01Q\x80Qa\x04\0\x88\x01R\x83\x01Qa\x04 \x87\x01R\x90\x88\x01Q\x80Qa\x04@\x87\x01R\x82\x01Qa\x04`\x86\x01Ra\x02`\x88\x01Q\x80Qa\x04\x80\x87\x01R\x90\x91\x01Qa\x04\xA0\x85\x01R\x86\x01Qa\x04\xC0\x84\x01RPa\x02\xA0\x85\x01Qa\x04\xE0\x83\x01Ra)\x14a\x05\0\x83\x01\x85a$\xF6V[a)\"a\x05\xE0\x83\x01\x84a%\x18V[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a):W_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x1C\xC3W_\x80\xFD[`\x01`\x01`@\x1B\x03\x82\x81\x16\x82\x82\x16\x03\x90\x80\x82\x11\x15a)iWa)ia$\xA6V[P\x92\x91PPV[_`\x01`\x01`@\x1B\x03\x80\x83\x16\x81\x81\x03a)\x8BWa)\x8Ba$\xA6V[`\x01\x01\x93\x92PPPV[_\x82Qa)\xA6\x81\x84` \x87\x01a$\x1BV[\x91\x90\x91\x01\x92\x91PPV\xFE6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x17\0\n", ); /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`. - ```solidity - error AddressEmptyCode(address target); - ```*/ +```solidity +error AddressEmptyCode(address target); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct AddressEmptyCode { @@ -3016,11 +3272,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3040,7 +3298,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for AddressEmptyCode { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "AddressEmptyCode(address)"; const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8]; #[inline] @@ -3060,9 +3320,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`. - ```solidity - error ERC1967InvalidImplementation(address implementation); - ```*/ +```solidity +error ERC1967InvalidImplementation(address implementation); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967InvalidImplementation { @@ -3083,33 +3343,37 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: ERC1967InvalidImplementation) -> Self { (value.implementation,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for ERC1967InvalidImplementation { + impl ::core::convert::From> + for ERC1967InvalidImplementation { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - implementation: tuple.0, - } + Self { implementation: tuple.0 } } } #[automatically_derived] impl alloy_sol_types::SolError for ERC1967InvalidImplementation { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)"; const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8]; #[inline] @@ -3129,9 +3393,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`. - ```solidity - error ERC1967NonPayable(); - ```*/ +```solidity +error ERC1967NonPayable(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967NonPayable {} @@ -3149,11 +3413,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3173,7 +3439,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for ERC1967NonPayable { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967NonPayable()"; const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8]; #[inline] @@ -3189,9 +3457,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`. - ```solidity - error FailedInnerCall(); - ```*/ +```solidity +error FailedInnerCall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FailedInnerCall {} @@ -3209,11 +3477,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3233,7 +3503,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for FailedInnerCall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FailedInnerCall()"; const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8]; #[inline] @@ -3249,9 +3521,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InsufficientSnapshotHistory()` and selector `0xb0b43877`. - ```solidity - error InsufficientSnapshotHistory(); - ```*/ +```solidity +error InsufficientSnapshotHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InsufficientSnapshotHistory {} @@ -3269,23 +3541,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InsufficientSnapshotHistory) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InsufficientSnapshotHistory { + impl ::core::convert::From> + for InsufficientSnapshotHistory { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3293,7 +3569,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InsufficientSnapshotHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InsufficientSnapshotHistory()"; const SELECTOR: [u8; 4] = [176u8, 180u8, 56u8, 119u8]; #[inline] @@ -3309,9 +3587,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidAddress()` and selector `0xe6c4247b`. - ```solidity - error InvalidAddress(); - ```*/ +```solidity +error InvalidAddress(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidAddress {} @@ -3329,11 +3607,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3353,7 +3633,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidAddress { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidAddress()"; const SELECTOR: [u8; 4] = [230u8, 196u8, 36u8, 123u8]; #[inline] @@ -3369,9 +3651,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidArgs()` and selector `0xa1ba07ee`. - ```solidity - error InvalidArgs(); - ```*/ +```solidity +error InvalidArgs(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidArgs {} @@ -3389,11 +3671,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3413,7 +3697,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidArgs { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidArgs()"; const SELECTOR: [u8; 4] = [161u8, 186u8, 7u8, 238u8]; #[inline] @@ -3429,9 +3715,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidHotShotBlockForCommitmentCheck()` and selector `0x615a9264`. - ```solidity - error InvalidHotShotBlockForCommitmentCheck(); - ```*/ +```solidity +error InvalidHotShotBlockForCommitmentCheck(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidHotShotBlockForCommitmentCheck {} @@ -3449,23 +3735,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InvalidHotShotBlockForCommitmentCheck) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InvalidHotShotBlockForCommitmentCheck { + impl ::core::convert::From> + for InvalidHotShotBlockForCommitmentCheck { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3473,7 +3763,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidHotShotBlockForCommitmentCheck { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidHotShotBlockForCommitmentCheck()"; const SELECTOR: [u8; 4] = [97u8, 90u8, 146u8, 100u8]; #[inline] @@ -3489,9 +3781,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`. - ```solidity - error InvalidInitialization(); - ```*/ +```solidity +error InvalidInitialization(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidInitialization {} @@ -3509,11 +3801,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3533,7 +3827,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidInitialization { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidInitialization()"; const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8]; #[inline] @@ -3549,9 +3845,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidMaxStateHistory()` and selector `0xf4a0eee0`. - ```solidity - error InvalidMaxStateHistory(); - ```*/ +```solidity +error InvalidMaxStateHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidMaxStateHistory {} @@ -3569,11 +3865,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3593,7 +3891,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidMaxStateHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidMaxStateHistory()"; const SELECTOR: [u8; 4] = [244u8, 160u8, 238u8, 224u8]; #[inline] @@ -3609,9 +3909,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `InvalidProof()` and selector `0x09bde339`. - ```solidity - error InvalidProof(); - ```*/ +```solidity +error InvalidProof(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidProof {} @@ -3629,11 +3929,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3653,7 +3955,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for InvalidProof { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidProof()"; const SELECTOR: [u8; 4] = [9u8, 189u8, 227u8, 57u8]; #[inline] @@ -3669,9 +3973,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `NoChangeRequired()` and selector `0xa863aec9`. - ```solidity - error NoChangeRequired(); - ```*/ +```solidity +error NoChangeRequired(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NoChangeRequired {} @@ -3689,11 +3993,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3713,7 +4019,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for NoChangeRequired { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NoChangeRequired()"; const SELECTOR: [u8; 4] = [168u8, 99u8, 174u8, 201u8]; #[inline] @@ -3729,9 +4037,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`. - ```solidity - error NotInitializing(); - ```*/ +```solidity +error NotInitializing(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NotInitializing {} @@ -3749,11 +4057,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3773,7 +4083,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for NotInitializing { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NotInitializing()"; const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8]; #[inline] @@ -3789,9 +4101,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `OutdatedState()` and selector `0x051c46ef`. - ```solidity - error OutdatedState(); - ```*/ +```solidity +error OutdatedState(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OutdatedState {} @@ -3809,11 +4121,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3833,7 +4147,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for OutdatedState { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OutdatedState()"; const SELECTOR: [u8; 4] = [5u8, 28u8, 70u8, 239u8]; #[inline] @@ -3849,9 +4165,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`. - ```solidity - error OwnableInvalidOwner(address owner); - ```*/ +```solidity +error OwnableInvalidOwner(address owner); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableInvalidOwner { @@ -3872,11 +4188,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3896,7 +4214,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for OwnableInvalidOwner { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableInvalidOwner(address)"; const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8]; #[inline] @@ -3916,9 +4236,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`. - ```solidity - error OwnableUnauthorizedAccount(address account); - ```*/ +```solidity +error OwnableUnauthorizedAccount(address account); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableUnauthorizedAccount { @@ -3939,23 +4259,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: OwnableUnauthorizedAccount) -> Self { (value.account,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for OwnableUnauthorizedAccount { + impl ::core::convert::From> + for OwnableUnauthorizedAccount { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { account: tuple.0 } } @@ -3963,7 +4287,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for OwnableUnauthorizedAccount { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)"; const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8]; #[inline] @@ -3983,9 +4309,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `ProverNotPermissioned()` and selector `0xa3a64780`. - ```solidity - error ProverNotPermissioned(); - ```*/ +```solidity +error ProverNotPermissioned(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ProverNotPermissioned {} @@ -4003,11 +4329,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4027,7 +4355,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for ProverNotPermissioned { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ProverNotPermissioned()"; const SELECTOR: [u8; 4] = [163u8, 166u8, 71u8, 128u8]; #[inline] @@ -4043,9 +4373,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`. - ```solidity - error UUPSUnauthorizedCallContext(); - ```*/ +```solidity +error UUPSUnauthorizedCallContext(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnauthorizedCallContext {} @@ -4063,23 +4393,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnauthorizedCallContext) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnauthorizedCallContext { + impl ::core::convert::From> + for UUPSUnauthorizedCallContext { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -4087,7 +4421,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()"; const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8]; #[inline] @@ -4103,9 +4439,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`. - ```solidity - error UUPSUnsupportedProxiableUUID(bytes32 slot); - ```*/ +```solidity +error UUPSUnsupportedProxiableUUID(bytes32 slot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnsupportedProxiableUUID { @@ -4126,23 +4462,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnsupportedProxiableUUID) -> Self { (value.slot,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnsupportedProxiableUUID { + impl ::core::convert::From> + for UUPSUnsupportedProxiableUUID { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { slot: tuple.0 } } @@ -4150,7 +4490,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)"; const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8]; #[inline] @@ -4170,9 +4512,9 @@ pub mod LightClientArbitrum { } }; /**Custom error with signature `WrongStakeTableUsed()` and selector `0x51618089`. - ```solidity - error WrongStakeTableUsed(); - ```*/ +```solidity +error WrongStakeTableUsed(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct WrongStakeTableUsed {} @@ -4190,11 +4532,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4214,7 +4558,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolError for WrongStakeTableUsed { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "WrongStakeTableUsed()"; const SELECTOR: [u8; 4] = [81u8, 97u8, 128u8, 137u8]; #[inline] @@ -4230,9 +4576,9 @@ pub mod LightClientArbitrum { } }; /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`. - ```solidity - event Initialized(uint64 version); - ```*/ +```solidity +event Initialized(uint64 version); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4255,15 +4601,45 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for Initialized { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Initialized(uint64)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4278,20 +4654,22 @@ pub mod LightClientArbitrum { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.version, - ), + as alloy_sol_types::SolType>::tokenize(&self.version), ) } #[inline] @@ -4306,7 +4684,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4328,9 +4708,9 @@ pub mod LightClientArbitrum { } }; /**Event with signature `NewState(uint64,uint64,uint256)` and selector `0xa04a773924505a418564363725f56832f5772e6b8d0dbd6efce724dfe803dae6`. - ```solidity - event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4357,19 +4737,49 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for NewState { type DataTuple<'a> = (BN254::ScalarField,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, ); const SIGNATURE: &'static str = "NewState(uint64,uint64,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, - 37u8, 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, - 252u8, 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4388,19 +4798,23 @@ pub mod LightClientArbitrum { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { - (::tokenize( - &self.blockCommRoot, - ),) + ( + ::tokenize( + &self.blockCommRoot, + ), + ) } #[inline] fn topics(&self) -> ::RustType { @@ -4418,7 +4832,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.viewNum); @@ -4446,9 +4862,9 @@ pub mod LightClientArbitrum { } }; /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. - ```solidity - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - ```*/ +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4473,19 +4889,49 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for OwnershipTransferred { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, - 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, - 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4503,11 +4949,13 @@ pub mod LightClientArbitrum { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4531,7 +4979,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.previousOwner, ); @@ -4559,9 +5009,9 @@ pub mod LightClientArbitrum { } }; /**Event with signature `PermissionedProverNotRequired()` and selector `0x9a5f57de856dd668c54dd95e5c55df93432171cbca49a8776d5620ea59c02450`. - ```solidity - event PermissionedProverNotRequired(); - ```*/ +```solidity +event PermissionedProverNotRequired(); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4581,15 +5031,45 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverNotRequired { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverNotRequired()"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4604,11 +5084,13 @@ pub mod LightClientArbitrum { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4628,7 +5110,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4644,15 +5128,17 @@ pub mod LightClientArbitrum { #[automatically_derived] impl From<&PermissionedProverNotRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverNotRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverNotRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `PermissionedProverRequired(address)` and selector `0x8017bb887fdf8fca4314a9d40f6e73b3b81002d67e5cfa85d88173af6aa46072`. - ```solidity - event PermissionedProverRequired(address permissionedProver); - ```*/ +```solidity +event PermissionedProverRequired(address permissionedProver); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4675,15 +5161,45 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverRequired { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverRequired(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, - 212u8, 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, - 133u8, 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4691,20 +5207,20 @@ pub mod LightClientArbitrum { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - permissionedProver: data.0, - } + Self { permissionedProver: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4728,7 +5244,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4744,15 +5262,17 @@ pub mod LightClientArbitrum { #[automatically_derived] impl From<&PermissionedProverRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `Upgrade(address)` and selector `0xf78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d`. - ```solidity - event Upgrade(address implementation); - ```*/ +```solidity +event Upgrade(address implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4775,15 +5295,45 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgrade { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Upgrade(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, - 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4791,20 +5341,20 @@ pub mod LightClientArbitrum { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: data.0, - } + Self { implementation: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4828,7 +5378,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4850,9 +5402,9 @@ pub mod LightClientArbitrum { } }; /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. - ```solidity - event Upgraded(address indexed implementation); - ```*/ +```solidity +event Upgraded(address indexed implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4875,18 +5427,48 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgraded { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Upgraded(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, - 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, - 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4894,20 +5476,20 @@ pub mod LightClientArbitrum { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: topics.1, - } + Self { implementation: topics.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4927,7 +5509,9 @@ pub mod LightClientArbitrum { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.implementation, ); @@ -4952,9 +5536,9 @@ pub mod LightClientArbitrum { } }; /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`. - ```solidity - function UPGRADE_INTERFACE_VERSION() external view returns (string memory); - ```*/ +```solidity +function UPGRADE_INTERFACE_VERSION() external view returns (string memory); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UPGRADE_INTERFACE_VERSIONCall {} @@ -4980,23 +5564,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONCall { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5009,23 +5597,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONReturn { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5034,10 +5626,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = UPGRADE_INTERFACE_VERSIONReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()"; const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8]; #[inline] @@ -5055,17 +5651,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `currentBlockNumber()` and selector `0x378ec23b`. - ```solidity - function currentBlockNumber() external view returns (uint256); - ```*/ +```solidity +function currentBlockNumber() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct currentBlockNumberCall {} @@ -5091,23 +5687,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberCall { + impl ::core::convert::From> + for currentBlockNumberCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5117,26 +5717,32 @@ pub mod LightClientArbitrum { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberReturn { + impl ::core::convert::From> + for currentBlockNumberReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5145,10 +5751,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for currentBlockNumberCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = currentBlockNumberReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "currentBlockNumber()"; const SELECTOR: [u8; 4] = [55u8, 142u8, 194u8, 59u8]; #[inline] @@ -5166,17 +5776,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `disablePermissionedProverMode()` and selector `0x69cc6a04`. - ```solidity - function disablePermissionedProverMode() external; - ```*/ +```solidity +function disablePermissionedProverMode() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct disablePermissionedProverModeCall {} @@ -5199,23 +5809,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeCall { + impl ::core::convert::From> + for disablePermissionedProverModeCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5228,23 +5842,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeReturn { + impl ::core::convert::From> + for disablePermissionedProverModeReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5253,10 +5871,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for disablePermissionedProverModeCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = disablePermissionedProverModeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "disablePermissionedProverMode()"; const SELECTOR: [u8; 4] = [105u8, 204u8, 106u8, 4u8]; #[inline] @@ -5274,17 +5896,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `finalizedState()` and selector `0x9fdb54a7`. - ```solidity - function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct finalizedStateCall {} @@ -5314,11 +5936,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5351,23 +5975,27 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: finalizedStateReturn) -> Self { (value.viewNum, value.blockHeight, value.blockCommRoot) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for finalizedStateReturn { + impl ::core::convert::From> + for finalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { viewNum: tuple.0, @@ -5380,14 +6008,18 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for finalizedStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = finalizedStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "finalizedState()"; const SELECTOR: [u8; 4] = [159u8, 219u8, 84u8, 167u8]; #[inline] @@ -5405,17 +6037,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisStakeTableState()` and selector `0x426d3194`. - ```solidity - function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); - ```*/ +```solidity +function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStakeTableStateCall {} @@ -5447,23 +6079,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateCall { + impl ::core::convert::From> + for genesisStakeTableStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5486,16 +6122,19 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateReturn) -> Self { ( value.threshold, @@ -5507,7 +6146,8 @@ pub mod LightClientArbitrum { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateReturn { + impl ::core::convert::From> + for genesisStakeTableStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { threshold: tuple.0, @@ -5521,7 +6161,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStakeTableStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStakeTableStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<256>, @@ -5529,7 +6171,9 @@ pub mod LightClientArbitrum { BN254::ScalarField, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisStakeTableState()"; const SELECTOR: [u8; 4] = [66u8, 109u8, 49u8, 148u8]; #[inline] @@ -5547,17 +6191,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisState()` and selector `0xd24d933d`. - ```solidity - function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStateCall {} @@ -5587,11 +6231,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5624,11 +6270,13 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5653,14 +6301,18 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisState()"; const SELECTOR: [u8; 4] = [210u8, 77u8, 147u8, 61u8]; #[inline] @@ -5678,17 +6330,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getHotShotCommitment(uint256)` and selector `0x8584d23f`. - ```solidity - function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); - ```*/ +```solidity +function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getHotShotCommitmentCall { @@ -5716,26 +6368,32 @@ pub mod LightClientArbitrum { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentCall) -> Self { (value.hotShotBlockHeight,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentCall { + impl ::core::convert::From> + for getHotShotCommitmentCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockHeight: tuple.0, @@ -5745,8 +6403,10 @@ pub mod LightClientArbitrum { } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); + type UnderlyingSolTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( ::RustType, @@ -5754,23 +6414,27 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentReturn) -> Self { (value.hotShotBlockCommRoot, value.hotshotBlockHeight) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentReturn { + impl ::core::convert::From> + for getHotShotCommitmentReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockCommRoot: tuple.0, @@ -5782,10 +6446,17 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for getHotShotCommitmentCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getHotShotCommitmentReturn; - type ReturnTuple<'a> = (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getHotShotCommitment(uint256)"; const SELECTOR: [u8; 4] = [133u8, 132u8, 210u8, 63u8]; #[inline] @@ -5797,9 +6468,9 @@ pub mod LightClientArbitrum { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.hotShotBlockHeight, - ), + as alloy_sol_types::SolType>::tokenize(&self.hotShotBlockHeight), ) } #[inline] @@ -5807,17 +6478,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getStateHistoryCount()` and selector `0xf9e50d19`. - ```solidity - function getStateHistoryCount() external view returns (uint256); - ```*/ +```solidity +function getStateHistoryCount() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getStateHistoryCountCall {} @@ -5843,23 +6514,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountCall { + impl ::core::convert::From> + for getStateHistoryCountCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5869,26 +6544,32 @@ pub mod LightClientArbitrum { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountReturn { + impl ::core::convert::From> + for getStateHistoryCountReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5897,10 +6578,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for getStateHistoryCountCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getStateHistoryCountReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getStateHistoryCount()"; const SELECTOR: [u8; 4] = [249u8, 229u8, 13u8, 25u8]; #[inline] @@ -5918,17 +6603,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getVersion()` and selector `0x0d8e6e2c`. - ```solidity - function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); - ```*/ +```solidity +function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getVersionCall {} @@ -5958,11 +6643,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5991,11 +6678,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (u8, u8, u8); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6020,14 +6709,18 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for getVersionCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getVersionReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getVersion()"; const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8]; #[inline] @@ -6045,25 +6738,24 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)` and selector `0x9baa3cc9`. - ```solidity - function initialize(LightClient.LightClientState memory _genesis, LightClient.StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; - ```*/ +```solidity +function initialize(LightClient.LightClientState memory _genesis, LightClient.StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializeCall { #[allow(missing_docs)] pub _genesis: ::RustType, #[allow(missing_docs)] - pub _genesisStakeTableState: - ::RustType, + pub _genesisStakeTableState: ::RustType, #[allow(missing_docs)] pub _stateHistoryRetentionPeriod: u32, #[allow(missing_docs)] @@ -6098,11 +6790,13 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6137,11 +6831,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6167,10 +6863,14 @@ pub mod LightClientArbitrum { alloy::sol_types::sol_data::Uint<32>, alloy::sol_types::sol_data::Address, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)"; const SELECTOR: [u8; 4] = [155u8, 170u8, 60u8, 201u8]; #[inline] @@ -6188,7 +6888,9 @@ pub mod LightClientArbitrum { ::tokenize( &self._genesisStakeTableState, ), - as alloy_sol_types::SolType>::tokenize( + as alloy_sol_types::SolType>::tokenize( &self._stateHistoryRetentionPeriod, ), ::tokenize( @@ -6201,17 +6903,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `isPermissionedProverEnabled()` and selector `0x826e41fc`. - ```solidity - function isPermissionedProverEnabled() external view returns (bool); - ```*/ +```solidity +function isPermissionedProverEnabled() external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct isPermissionedProverEnabledCall {} @@ -6237,23 +6939,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledCall { + impl ::core::convert::From> + for isPermissionedProverEnabledCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6266,23 +6972,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledReturn { + impl ::core::convert::From> + for isPermissionedProverEnabledReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6291,10 +7001,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for isPermissionedProverEnabledCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = isPermissionedProverEnabledReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "isPermissionedProverEnabled()"; const SELECTOR: [u8; 4] = [130u8, 110u8, 65u8, 252u8]; #[inline] @@ -6312,17 +7026,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `lagOverEscapeHatchThreshold(uint256,uint256)` and selector `0xe0303301`. - ```solidity - function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 blockThreshold) external view returns (bool); - ```*/ +```solidity +function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 blockThreshold) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct lagOverEscapeHatchThresholdCall { @@ -6359,23 +7073,27 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdCall) -> Self { (value.blockNumber, value.blockThreshold) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdCall { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { blockNumber: tuple.0, @@ -6391,23 +7109,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdReturn { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6419,10 +7141,14 @@ pub mod LightClientArbitrum { alloy::sol_types::sol_data::Uint<256>, alloy::sol_types::sol_data::Uint<256>, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = lagOverEscapeHatchThresholdReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "lagOverEscapeHatchThreshold(uint256,uint256)"; const SELECTOR: [u8; 4] = [224u8, 48u8, 51u8, 1u8]; #[inline] @@ -6434,12 +7160,12 @@ pub mod LightClientArbitrum { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.blockNumber, - ), - as alloy_sol_types::SolType>::tokenize( - &self.blockThreshold, - ), + as alloy_sol_types::SolType>::tokenize(&self.blockNumber), + as alloy_sol_types::SolType>::tokenize(&self.blockThreshold), ) } #[inline] @@ -6447,17 +7173,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x2063d4f7`. - ```solidity - function newFinalizedState(LightClient.LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; - ```*/ +```solidity +function newFinalizedState(LightClient.LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct newFinalizedStateCall { @@ -6480,8 +7206,10 @@ pub mod LightClientArbitrum { use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (LightClient::LightClientState, IPlonkVerifier::PlonkProof); + type UnderlyingSolTuple<'a> = ( + LightClient::LightClientState, + IPlonkVerifier::PlonkProof, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( ::RustType, @@ -6489,23 +7217,27 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateCall) -> Self { (value.newState, value.proof) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateCall { + impl ::core::convert::From> + for newFinalizedStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newState: tuple.0, @@ -6521,23 +7253,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateReturn { + impl ::core::convert::From> + for newFinalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6545,11 +7281,18 @@ pub mod LightClientArbitrum { } #[automatically_derived] impl alloy_sol_types::SolCall for newFinalizedStateCall { - type Parameters<'a> = (LightClient::LightClientState, IPlonkVerifier::PlonkProof); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Parameters<'a> = ( + LightClient::LightClientState, + IPlonkVerifier::PlonkProof, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = newFinalizedStateReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [32u8, 99u8, 212u8, 247u8]; #[inline] @@ -6564,7 +7307,9 @@ pub mod LightClientArbitrum { ::tokenize( &self.newState, ), - ::tokenize(&self.proof), + ::tokenize( + &self.proof, + ), ) } #[inline] @@ -6572,17 +7317,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `owner()` and selector `0x8da5cb5b`. - ```solidity - function owner() external view returns (address); - ```*/ +```solidity +function owner() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ownerCall {} @@ -6608,11 +7353,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6637,11 +7384,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6662,10 +7411,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for ownerCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = ownerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "owner()"; const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; #[inline] @@ -6683,17 +7436,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `permissionedProver()` and selector `0x313df7b1`. - ```solidity - function permissionedProver() external view returns (address); - ```*/ +```solidity +function permissionedProver() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct permissionedProverCall {} @@ -6719,23 +7472,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverCall { + impl ::core::convert::From> + for permissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6748,23 +7505,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverReturn { + impl ::core::convert::From> + for permissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6773,10 +7534,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for permissionedProverCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = permissionedProverReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "permissionedProver()"; const SELECTOR: [u8; 4] = [49u8, 61u8, 247u8, 177u8]; #[inline] @@ -6794,17 +7559,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `proxiableUUID()` and selector `0x52d1902d`. - ```solidity - function proxiableUUID() external view returns (bytes32); - ```*/ +```solidity +function proxiableUUID() external view returns (bytes32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct proxiableUUIDCall {} @@ -6830,11 +7595,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6859,11 +7626,13 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6884,10 +7653,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for proxiableUUIDCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = proxiableUUIDReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "proxiableUUID()"; const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8]; #[inline] @@ -6905,17 +7678,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `renounceOwnership()` and selector `0x715018a6`. - ```solidity - function renounceOwnership() external; - ```*/ +```solidity +function renounceOwnership() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct renounceOwnershipCall {} @@ -6938,23 +7711,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipCall { + impl ::core::convert::From> + for renounceOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6967,23 +7744,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipReturn { + impl ::core::convert::From> + for renounceOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6992,10 +7773,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for renounceOwnershipCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = renounceOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "renounceOwnership()"; const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; #[inline] @@ -7013,17 +7798,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setPermissionedProver(address)` and selector `0x013fa5fc`. - ```solidity - function setPermissionedProver(address prover) external; - ```*/ +```solidity +function setPermissionedProver(address prover) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setPermissionedProverCall { @@ -7049,23 +7834,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverCall) -> Self { (value.prover,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverCall { + impl ::core::convert::From> + for setPermissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { prover: tuple.0 } } @@ -7078,23 +7867,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverReturn { + impl ::core::convert::From> + for setPermissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7103,10 +7896,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for setPermissionedProverCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setPermissionedProverReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setPermissionedProver(address)"; const SELECTOR: [u8; 4] = [1u8, 63u8, 165u8, 252u8]; #[inline] @@ -7128,17 +7925,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setstateHistoryRetentionPeriod(uint32)` and selector `0x96c1ca61`. - ```solidity - function setstateHistoryRetentionPeriod(uint32 historySeconds) external; - ```*/ +```solidity +function setstateHistoryRetentionPeriod(uint32 historySeconds) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setstateHistoryRetentionPeriodCall { @@ -7164,27 +7961,29 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodCall) -> Self { (value.historySeconds,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - historySeconds: tuple.0, - } + Self { historySeconds: tuple.0 } } } } @@ -7195,23 +7994,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7220,10 +8023,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for setstateHistoryRetentionPeriodCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setstateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setstateHistoryRetentionPeriod(uint32)"; const SELECTOR: [u8; 4] = [150u8, 193u8, 202u8, 97u8]; #[inline] @@ -7235,9 +8042,9 @@ pub mod LightClientArbitrum { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.historySeconds, - ), + as alloy_sol_types::SolType>::tokenize(&self.historySeconds), ) } #[inline] @@ -7245,17 +8052,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryCommitments(uint256)` and selector `0x02b592f3`. - ```solidity - function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); - ```*/ +```solidity +function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryCommitmentsCall { @@ -7287,26 +8094,32 @@ pub mod LightClientArbitrum { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsCall) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsCall { + impl ::core::convert::From> + for stateHistoryCommitmentsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7329,16 +8142,19 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsReturn) -> Self { ( value.l1BlockHeight, @@ -7350,7 +8166,8 @@ pub mod LightClientArbitrum { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsReturn { + impl ::core::convert::From> + for stateHistoryCommitmentsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { l1BlockHeight: tuple.0, @@ -7364,7 +8181,9 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryCommitmentsCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryCommitmentsReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, @@ -7372,7 +8191,9 @@ pub mod LightClientArbitrum { alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryCommitments(uint256)"; const SELECTOR: [u8; 4] = [2u8, 181u8, 146u8, 243u8]; #[inline] @@ -7384,9 +8205,9 @@ pub mod LightClientArbitrum { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self._0, - ), + as alloy_sol_types::SolType>::tokenize(&self._0), ) } #[inline] @@ -7394,17 +8215,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryFirstIndex()` and selector `0x2f79889d`. - ```solidity - function stateHistoryFirstIndex() external view returns (uint64); - ```*/ +```solidity +function stateHistoryFirstIndex() external view returns (uint64); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryFirstIndexCall {} @@ -7430,23 +8251,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexCall { + impl ::core::convert::From> + for stateHistoryFirstIndexCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7459,23 +8284,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (u64,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexReturn { + impl ::core::convert::From> + for stateHistoryFirstIndexReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7484,10 +8313,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryFirstIndexCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryFirstIndexReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryFirstIndex()"; const SELECTOR: [u8; 4] = [47u8, 121u8, 136u8, 157u8]; #[inline] @@ -7505,17 +8338,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryRetentionPeriod()` and selector `0xc23b9e9e`. - ```solidity - function stateHistoryRetentionPeriod() external view returns (uint32); - ```*/ +```solidity +function stateHistoryRetentionPeriod() external view returns (uint32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryRetentionPeriodCall {} @@ -7541,23 +8374,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for stateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7570,23 +8407,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for stateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7595,10 +8436,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryRetentionPeriodCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryRetentionPeriod()"; const SELECTOR: [u8; 4] = [194u8, 59u8, 158u8, 158u8]; #[inline] @@ -7616,17 +8461,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. - ```solidity - function transferOwnership(address newOwner) external; - ```*/ +```solidity +function transferOwnership(address newOwner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct transferOwnershipCall { @@ -7652,23 +8497,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipCall) -> Self { (value.newOwner,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipCall { + impl ::core::convert::From> + for transferOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newOwner: tuple.0 } } @@ -7681,23 +8530,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipReturn { + impl ::core::convert::From> + for transferOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7706,10 +8559,14 @@ pub mod LightClientArbitrum { #[automatically_derived] impl alloy_sol_types::SolCall for transferOwnershipCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = transferOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "transferOwnership(address)"; const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; #[inline] @@ -7731,17 +8588,17 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`. - ```solidity - function upgradeToAndCall(address newImplementation, bytes memory data) external payable; - ```*/ +```solidity +function upgradeToAndCall(address newImplementation, bytes memory data) external payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct upgradeToAndCallCall { @@ -7775,23 +8632,27 @@ pub mod LightClientArbitrum { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallCall) -> Self { (value.newImplementation, value.data) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallCall { + impl ::core::convert::From> + for upgradeToAndCallCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newImplementation: tuple.0, @@ -7807,23 +8668,27 @@ pub mod LightClientArbitrum { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallReturn { + impl ::core::convert::From> + for upgradeToAndCallReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7835,10 +8700,14 @@ pub mod LightClientArbitrum { alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Bytes, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = upgradeToAndCallReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)"; const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8]; #[inline] @@ -7863,10 +8732,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -7966,66 +8835,74 @@ pub mod LightClientArbitrum { match self { Self::UPGRADE_INTERFACE_VERSION(_) => { ::SELECTOR - }, + } Self::currentBlockNumber(_) => { ::SELECTOR - }, + } Self::disablePermissionedProverMode(_) => { ::SELECTOR - }, + } Self::finalizedState(_) => { ::SELECTOR - }, + } Self::genesisStakeTableState(_) => { ::SELECTOR - }, - Self::genesisState(_) => ::SELECTOR, + } + Self::genesisState(_) => { + ::SELECTOR + } Self::getHotShotCommitment(_) => { ::SELECTOR - }, + } Self::getStateHistoryCount(_) => { ::SELECTOR - }, - Self::getVersion(_) => ::SELECTOR, - Self::initialize(_) => ::SELECTOR, + } + Self::getVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } Self::isPermissionedProverEnabled(_) => { ::SELECTOR - }, + } Self::lagOverEscapeHatchThreshold(_) => { ::SELECTOR - }, + } Self::newFinalizedState(_) => { ::SELECTOR - }, + } Self::owner(_) => ::SELECTOR, Self::permissionedProver(_) => { ::SELECTOR - }, - Self::proxiableUUID(_) => ::SELECTOR, + } + Self::proxiableUUID(_) => { + ::SELECTOR + } Self::renounceOwnership(_) => { ::SELECTOR - }, + } Self::setPermissionedProver(_) => { ::SELECTOR - }, + } Self::setstateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::stateHistoryCommitments(_) => { ::SELECTOR - }, + } Self::stateHistoryFirstIndex(_) => { ::SELECTOR - }, + } Self::stateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::transferOwnership(_) => { ::SELECTOR - }, + } Self::upgradeToAndCall(_) => { ::SELECTOR - }, + } } } #[inline] @@ -8046,17 +8923,17 @@ pub mod LightClientArbitrum { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn setPermissionedProver( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::setPermissionedProver) + data, + validate, + ) + .map(LightClientArbitrumCalls::setPermissionedProver) } setPermissionedProver }, @@ -8066,9 +8943,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::stateHistoryCommitments) + data, + validate, + ) + .map(LightClientArbitrumCalls::stateHistoryCommitments) } stateHistoryCommitments }, @@ -8077,7 +8955,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumCalls::getVersion) } getVersion @@ -8088,9 +8969,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::newFinalizedState) + data, + validate, + ) + .map(LightClientArbitrumCalls::newFinalizedState) } newFinalizedState }, @@ -8100,9 +8982,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::stateHistoryFirstIndex) + data, + validate, + ) + .map(LightClientArbitrumCalls::stateHistoryFirstIndex) } stateHistoryFirstIndex }, @@ -8112,9 +8995,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::permissionedProver) + data, + validate, + ) + .map(LightClientArbitrumCalls::permissionedProver) } permissionedProver }, @@ -8124,9 +9008,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::currentBlockNumber) + data, + validate, + ) + .map(LightClientArbitrumCalls::currentBlockNumber) } currentBlockNumber }, @@ -8136,9 +9021,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::genesisStakeTableState) + data, + validate, + ) + .map(LightClientArbitrumCalls::genesisStakeTableState) } genesisStakeTableState }, @@ -8148,9 +9034,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::upgradeToAndCall) + data, + validate, + ) + .map(LightClientArbitrumCalls::upgradeToAndCall) } upgradeToAndCall }, @@ -8160,9 +9047,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::proxiableUUID) + data, + validate, + ) + .map(LightClientArbitrumCalls::proxiableUUID) } proxiableUUID }, @@ -8185,9 +9073,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::renounceOwnership) + data, + validate, + ) + .map(LightClientArbitrumCalls::renounceOwnership) } renounceOwnership }, @@ -8210,9 +9099,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::getHotShotCommitment) + data, + validate, + ) + .map(LightClientArbitrumCalls::getHotShotCommitment) } getHotShotCommitment }, @@ -8221,7 +9111,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumCalls::owner) } owner @@ -8246,7 +9139,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumCalls::initialize) } initialize @@ -8257,9 +9153,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::finalizedState) + data, + validate, + ) + .map(LightClientArbitrumCalls::finalizedState) } finalizedState }, @@ -8269,9 +9166,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::UPGRADE_INTERFACE_VERSION) + data, + validate, + ) + .map(LightClientArbitrumCalls::UPGRADE_INTERFACE_VERSION) } UPGRADE_INTERFACE_VERSION }, @@ -8294,9 +9192,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::genesisState) + data, + validate, + ) + .map(LightClientArbitrumCalls::genesisState) } genesisState }, @@ -8319,9 +9218,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::transferOwnership) + data, + validate, + ) + .map(LightClientArbitrumCalls::transferOwnership) } transferOwnership }, @@ -8331,18 +9231,21 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumCalls::getStateHistoryCount) + data, + validate, + ) + .map(LightClientArbitrumCalls::getStateHistoryCount) } getStateHistoryCount }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -8470,100 +9373,145 @@ pub mod LightClientArbitrum { match self { Self::UPGRADE_INTERFACE_VERSION(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::currentBlockNumber(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::disablePermissionedProverMode(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::finalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::genesisStakeTableState(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::genesisState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::getHotShotCommitment(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getStateHistoryCount(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getVersion(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::initialize(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::isPermissionedProverEnabled(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::lagOverEscapeHatchThreshold(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::newFinalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::owner(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::permissionedProver(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::proxiableUUID(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::renounceOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setPermissionedProver(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::setstateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryCommitments(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryFirstIndex(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::transferOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::upgradeToAndCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -8651,56 +9599,64 @@ pub mod LightClientArbitrum { match self { Self::AddressEmptyCode(_) => { ::SELECTOR - }, + } Self::ERC1967InvalidImplementation(_) => { ::SELECTOR - }, + } Self::ERC1967NonPayable(_) => { ::SELECTOR - }, + } Self::FailedInnerCall(_) => { ::SELECTOR - }, + } Self::InsufficientSnapshotHistory(_) => { ::SELECTOR - }, - Self::InvalidAddress(_) => ::SELECTOR, - Self::InvalidArgs(_) => ::SELECTOR, + } + Self::InvalidAddress(_) => { + ::SELECTOR + } + Self::InvalidArgs(_) => { + ::SELECTOR + } Self::InvalidHotShotBlockForCommitmentCheck(_) => { ::SELECTOR - }, + } Self::InvalidInitialization(_) => { ::SELECTOR - }, + } Self::InvalidMaxStateHistory(_) => { ::SELECTOR - }, - Self::InvalidProof(_) => ::SELECTOR, + } + Self::InvalidProof(_) => { + ::SELECTOR + } Self::NoChangeRequired(_) => { ::SELECTOR - }, + } Self::NotInitializing(_) => { ::SELECTOR - }, - Self::OutdatedState(_) => ::SELECTOR, + } + Self::OutdatedState(_) => { + ::SELECTOR + } Self::OwnableInvalidOwner(_) => { ::SELECTOR - }, + } Self::OwnableUnauthorizedAccount(_) => { ::SELECTOR - }, + } Self::ProverNotPermissioned(_) => { ::SELECTOR - }, + } Self::UUPSUnauthorizedCallContext(_) => { ::SELECTOR - }, + } Self::UUPSUnsupportedProxiableUUID(_) => { ::SELECTOR - }, + } Self::WrongStakeTableUsed(_) => { ::SELECTOR - }, + } } } #[inline] @@ -8721,14 +9677,16 @@ pub mod LightClientArbitrum { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn OutdatedState( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumErrors::OutdatedState) } OutdatedState @@ -8738,7 +9696,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumErrors::InvalidProof) } InvalidProof @@ -8749,9 +9710,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::OwnableUnauthorizedAccount) + data, + validate, + ) + .map(LightClientArbitrumErrors::OwnableUnauthorizedAccount) } OwnableUnauthorizedAccount }, @@ -8761,9 +9723,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::FailedInnerCall) + data, + validate, + ) + .map(LightClientArbitrumErrors::FailedInnerCall) } FailedInnerCall }, @@ -8773,9 +9736,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::OwnableInvalidOwner) + data, + validate, + ) + .map(LightClientArbitrumErrors::OwnableInvalidOwner) } OwnableInvalidOwner }, @@ -8785,9 +9749,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::ERC1967InvalidImplementation) + data, + validate, + ) + .map(LightClientArbitrumErrors::ERC1967InvalidImplementation) } ERC1967InvalidImplementation }, @@ -8797,9 +9762,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::WrongStakeTableUsed) + data, + validate, + ) + .map(LightClientArbitrumErrors::WrongStakeTableUsed) } WrongStakeTableUsed }, @@ -8824,9 +9790,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::AddressEmptyCode) + data, + validate, + ) + .map(LightClientArbitrumErrors::AddressEmptyCode) } AddressEmptyCode }, @@ -8835,7 +9802,10 @@ pub mod LightClientArbitrum { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientArbitrumErrors::InvalidArgs) } InvalidArgs @@ -8846,9 +9816,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::ProverNotPermissioned) + data, + validate, + ) + .map(LightClientArbitrumErrors::ProverNotPermissioned) } ProverNotPermissioned }, @@ -8858,9 +9829,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::NoChangeRequired) + data, + validate, + ) + .map(LightClientArbitrumErrors::NoChangeRequired) } NoChangeRequired }, @@ -8870,9 +9842,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::UUPSUnsupportedProxiableUUID) + data, + validate, + ) + .map(LightClientArbitrumErrors::UUPSUnsupportedProxiableUUID) } UUPSUnsupportedProxiableUUID }, @@ -8882,9 +9855,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::InsufficientSnapshotHistory) + data, + validate, + ) + .map(LightClientArbitrumErrors::InsufficientSnapshotHistory) } InsufficientSnapshotHistory }, @@ -8894,9 +9868,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::ERC1967NonPayable) + data, + validate, + ) + .map(LightClientArbitrumErrors::ERC1967NonPayable) } ERC1967NonPayable }, @@ -8906,9 +9881,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::NotInitializing) + data, + validate, + ) + .map(LightClientArbitrumErrors::NotInitializing) } NotInitializing }, @@ -8918,9 +9894,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::UUPSUnauthorizedCallContext) + data, + validate, + ) + .map(LightClientArbitrumErrors::UUPSUnauthorizedCallContext) } UUPSUnauthorizedCallContext }, @@ -8930,9 +9907,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::InvalidAddress) + data, + validate, + ) + .map(LightClientArbitrumErrors::InvalidAddress) } InvalidAddress }, @@ -8942,9 +9920,10 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::InvalidMaxStateHistory) + data, + validate, + ) + .map(LightClientArbitrumErrors::InvalidMaxStateHistory) } InvalidMaxStateHistory }, @@ -8954,18 +9933,21 @@ pub mod LightClientArbitrum { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientArbitrumErrors::InvalidInitialization) + data, + validate, + ) + .map(LightClientArbitrumErrors::InvalidInitialization) } InvalidInitialization }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -9221,39 +10203,242 @@ pub mod LightClientArbitrum { /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 32usize]] = &[ [ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, 212u8, - 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, 133u8, - 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, ], [ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8, - 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8, - 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, ], [ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, ], [ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, 37u8, - 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, 252u8, - 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, ], [ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8, - 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8, - 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, ], [ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, ], [ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8, - 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, ], ]; } @@ -9269,49 +10454,77 @@ pub mod LightClientArbitrum { match topics.first().copied() { Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::Initialized) - }, + topics, + data, + validate, + ) + .map(Self::Initialized) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::NewState) - }, - Some(::SIGNATURE_HASH) => { + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::OwnershipTransferred) - }, + topics, + data, + validate, + ) + .map(Self::OwnershipTransferred) + } Some( ::SIGNATURE_HASH, - ) => ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverNotRequired), - Some(::SIGNATURE_HASH) => { + ) => { + ::decode_raw_log( + topics, + data, + validate, + ) + .map(Self::PermissionedProverNotRequired) + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverRequired) - }, + topics, + data, + validate, + ) + .map(Self::PermissionedProverRequired) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgrade) - }, + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgraded) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -9321,49 +10534,57 @@ pub mod LightClientArbitrum { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::NewState(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::NewState(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), - Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::NewState(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::Upgraded(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`LightClientArbitrum`](self) contract instance. - See the [wrapper's documentation](`LightClientArbitrumInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientArbitrumInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -9377,9 +10598,9 @@ pub mod LightClientArbitrum { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -9387,36 +10608,35 @@ pub mod LightClientArbitrum { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { LightClientArbitrumInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { LightClientArbitrumInstance::::deploy_builder(provider) } /**A [`LightClientArbitrum`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`LightClientArbitrum`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`LightClientArbitrum`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct LightClientArbitrumInstance { address: alloy_sol_types::private::Address, @@ -9427,24 +10647,24 @@ pub mod LightClientArbitrum { impl ::core::fmt::Debug for LightClientArbitrumInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightClientArbitrumInstance") - .field(&self.address) - .finish() + f.debug_tuple("LightClientArbitrumInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientArbitrumInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientArbitrumInstance { /**Creates a new wrapper around an on-chain [`LightClientArbitrum`](self) contract instance. - See the [wrapper's documentation](`LightClientArbitrumInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientArbitrumInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -9453,9 +10673,9 @@ pub mod LightClientArbitrum { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -9465,10 +10685,10 @@ pub mod LightClientArbitrum { Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -9511,11 +10731,10 @@ pub mod LightClientArbitrum { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientArbitrumInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientArbitrumInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -9541,8 +10760,16 @@ pub mod LightClientArbitrum { ///Creates a new call builder for the [`disablePermissionedProverMode`] function. pub fn disablePermissionedProverMode( &self, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&disablePermissionedProverModeCall {}) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + disablePermissionedProverModeCall, + N, + > { + self.call_builder( + &disablePermissionedProverModeCall { + }, + ) } ///Creates a new call builder for the [`finalizedState`] function. pub fn finalizedState( @@ -9557,7 +10784,9 @@ pub mod LightClientArbitrum { self.call_builder(&genesisStakeTableStateCall {}) } ///Creates a new call builder for the [`genesisState`] function. - pub fn genesisState(&self) -> alloy_contract::SolCallBuilder { + pub fn genesisState( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&genesisStateCall {}) } ///Creates a new call builder for the [`getHotShotCommitment`] function. @@ -9565,7 +10794,11 @@ pub mod LightClientArbitrum { &self, hotShotBlockHeight: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&getHotShotCommitmentCall { hotShotBlockHeight }) + self.call_builder( + &getHotShotCommitmentCall { + hotShotBlockHeight, + }, + ) } ///Creates a new call builder for the [`getStateHistoryCount`] function. pub fn getStateHistoryCount( @@ -9574,7 +10807,9 @@ pub mod LightClientArbitrum { self.call_builder(&getStateHistoryCountCall {}) } ///Creates a new call builder for the [`getVersion`] function. - pub fn getVersion(&self) -> alloy_contract::SolCallBuilder { + pub fn getVersion( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&getVersionCall {}) } ///Creates a new call builder for the [`initialize`] function. @@ -9585,12 +10820,14 @@ pub mod LightClientArbitrum { _stateHistoryRetentionPeriod: u32, owner: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&initializeCall { - _genesis, - _genesisStakeTableState, - _stateHistoryRetentionPeriod, - owner, - }) + self.call_builder( + &initializeCall { + _genesis, + _genesisStakeTableState, + _stateHistoryRetentionPeriod, + owner, + }, + ) } ///Creates a new call builder for the [`isPermissionedProverEnabled`] function. pub fn isPermissionedProverEnabled( @@ -9604,10 +10841,12 @@ pub mod LightClientArbitrum { blockNumber: alloy::sol_types::private::primitives::aliases::U256, blockThreshold: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&lagOverEscapeHatchThresholdCall { - blockNumber, - blockThreshold, - }) + self.call_builder( + &lagOverEscapeHatchThresholdCall { + blockNumber, + blockThreshold, + }, + ) } ///Creates a new call builder for the [`newFinalizedState`] function. pub fn newFinalizedState( @@ -9615,7 +10854,12 @@ pub mod LightClientArbitrum { newState: ::RustType, proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&newFinalizedStateCall { newState, proof }) + self.call_builder( + &newFinalizedStateCall { + newState, + proof, + }, + ) } ///Creates a new call builder for the [`owner`] function. pub fn owner(&self) -> alloy_contract::SolCallBuilder { @@ -9628,7 +10872,9 @@ pub mod LightClientArbitrum { self.call_builder(&permissionedProverCall {}) } ///Creates a new call builder for the [`proxiableUUID`] function. - pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder { + pub fn proxiableUUID( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&proxiableUUIDCall {}) } ///Creates a new call builder for the [`renounceOwnership`] function. @@ -9642,14 +10888,27 @@ pub mod LightClientArbitrum { &self, prover: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setPermissionedProverCall { prover }) + self.call_builder( + &setPermissionedProverCall { + prover, + }, + ) } ///Creates a new call builder for the [`setstateHistoryRetentionPeriod`] function. pub fn setstateHistoryRetentionPeriod( &self, historySeconds: u32, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setstateHistoryRetentionPeriodCall { historySeconds }) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + setstateHistoryRetentionPeriodCall, + N, + > { + self.call_builder( + &setstateHistoryRetentionPeriodCall { + historySeconds, + }, + ) } ///Creates a new call builder for the [`stateHistoryCommitments`] function. pub fn stateHistoryCommitments( @@ -9683,20 +10942,21 @@ pub mod LightClientArbitrum { newImplementation: alloy::sol_types::private::Address, data: alloy::sol_types::private::Bytes, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&upgradeToAndCallCall { - newImplementation, - data, - }) + self.call_builder( + &upgradeToAndCallCall { + newImplementation, + data, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientArbitrumInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientArbitrumInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -9707,7 +10967,9 @@ pub mod LightClientArbitrum { alloy_contract::Event::new_sol(&self.provider, &self.address) } ///Creates a new event filter for the [`Initialized`] event. - pub fn Initialized_filter(&self) -> alloy_contract::Event { + pub fn Initialized_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } ///Creates a new event filter for the [`NewState`] event. diff --git a/contract-bindings-alloy/src/lightclientmock.rs b/contract-bindings-alloy/src/lightclientmock.rs index 7feb65d5ef..b259ac1fc4 100644 --- a/contract-bindings-alloy/src/lightclientmock.rs +++ b/contract-bindings-alloy/src/lightclientmock.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -563,12 +620,11 @@ library IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -681,11 +737,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -764,23 +822,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -791,50 +871,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -848,111 +942,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) + .0, + ::eip712_data_word( + &self.wire3, + ) + .0, + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) + .0, + ::eip712_data_word( + &self.split1, + ) + .0, + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1035,7 +1231,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1081,7 +1279,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1129,17 +1328,24 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1153,15 +1359,15 @@ pub mod IPlonkVerifier { } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -1172,24 +1378,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1231,11 +1437,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -1250,11 +1455,10 @@ pub mod IPlonkVerifier { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -1284,12 +1488,11 @@ library LightClient { clippy::empty_structs_with_brackets )] pub mod LightClient { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } - ```*/ +struct LightClientState { uint64 viewNum; uint64 blockHeight; BN254.ScalarField blockCommRoot; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct LightClientState { @@ -1322,11 +1525,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1356,13 +1561,15 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.viewNum, - ), - as alloy_sol_types::SolType>::tokenize( - &self.blockHeight, + as alloy_sol_types::SolType>::tokenize(&self.viewNum), + as alloy_sol_types::SolType>::tokenize(&self.blockHeight), + ::tokenize( + &self.blockCommRoot, ), - ::tokenize(&self.blockCommRoot), ) } #[inline] @@ -1370,50 +1577,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for LightClientState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1427,9 +1648,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -1479,7 +1700,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1498,16 +1721,23 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } - ```*/ +struct StakeTableState { uint256 threshold; BN254.ScalarField blsKeyComm; BN254.ScalarField schnorrKeyComm; BN254.ScalarField amountComm; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StakeTableState { @@ -1544,11 +1774,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1584,14 +1816,18 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.threshold, + as alloy_sol_types::SolType>::tokenize(&self.threshold), + ::tokenize( + &self.blsKeyComm, ), - ::tokenize(&self.blsKeyComm), ::tokenize( &self.schnorrKeyComm, ), - ::tokenize(&self.amountComm), + ::tokenize( + &self.amountComm, + ), ) } #[inline] @@ -1599,50 +1835,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for StakeTableState { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1656,9 +1906,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -1713,7 +1963,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1734,16 +1986,23 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct StateHistoryCommitment { uint64 l1BlockHeight; uint64 l1BlockTimestamp; uint64 hotShotBlockHeight; BN254.ScalarField hotShotBlockCommRoot; } - ```*/ +struct StateHistoryCommitment { uint64 l1BlockHeight; uint64 l1BlockTimestamp; uint64 hotShotBlockHeight; BN254.ScalarField hotShotBlockCommRoot; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StateHistoryCommitment { @@ -1780,11 +2039,13 @@ pub mod LightClient { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1820,15 +2081,15 @@ pub mod LightClient { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.l1BlockHeight, - ), - as alloy_sol_types::SolType>::tokenize( - &self.l1BlockTimestamp, - ), - as alloy_sol_types::SolType>::tokenize( - &self.hotShotBlockHeight, - ), + as alloy_sol_types::SolType>::tokenize(&self.l1BlockHeight), + as alloy_sol_types::SolType>::tokenize(&self.l1BlockTimestamp), + as alloy_sol_types::SolType>::tokenize(&self.hotShotBlockHeight), ::tokenize( &self.hotShotBlockCommRoot, ), @@ -1839,50 +2100,64 @@ pub mod LightClient { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for StateHistoryCommitment { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1896,9 +2171,9 @@ pub mod LightClient { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -1961,7 +2236,9 @@ pub mod LightClient { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1986,17 +2263,24 @@ pub mod LightClient { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -2010,15 +2294,15 @@ pub mod LightClient { } /**A [`LightClient`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`LightClient`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`LightClient`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct LightClientInstance { address: alloy_sol_types::private::Address, @@ -2029,24 +2313,24 @@ pub mod LightClient { impl ::core::fmt::Debug for LightClientInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightClientInstance") - .field(&self.address) - .finish() + f.debug_tuple("LightClientInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /**Creates a new wrapper around an on-chain [`LightClient`](self) contract instance. - See the [wrapper's documentation](`LightClientInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -2088,11 +2372,10 @@ pub mod LightClient { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -2107,11 +2390,10 @@ pub mod LightClient { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -3379,9 +3661,8 @@ interface LightClientMock { clippy::empty_structs_with_brackets )] pub mod LightClientMock { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -3403,9 +3684,9 @@ pub mod LightClientMock { b"`\x80`@R`\x046\x10a\x01\xAFW_5`\xE0\x1C\x80c\x85\x84\xD2?\x11a\0\xE7W\x80c\xC2;\x9E\x9E\x11a\0\x87W\x80c\xE003\x01\x11a\0bW\x80c\xE003\x01\x14a\x06\x14W\x80c\xF2\xFD\xE3\x8B\x14a\x063W\x80c\xF5ga`\x14a\x06RW\x80c\xF9\xE5\r\x19\x14a\x06qW_\x80\xFD[\x80c\xC2;\x9E\x9E\x14a\x05\x92W\x80c\xC8\xE5\xE4\x98\x14a\x05\xCAW\x80c\xD2M\x93=\x14a\x05\xE5W_\x80\xFD[\x80c\x9B\xAA<\xC9\x11a\0\xC2W\x80c\x9B\xAA<\xC9\x14a\x04\x8AW\x80c\x9F\xDBT\xA7\x14a\x04\xA9W\x80c\xAD<\xB1\xCC\x14a\x04\xFEW\x80c\xB5\xAD\xEA<\x14a\x05;W_\x80\xFD[\x80c\x85\x84\xD2?\x14a\x03\xF3W\x80c\x8D\xA5\xCB[\x14a\x04/W\x80c\x96\xC1\xCAa\x14a\x04kW_\x80\xFD[\x80c7\x8E\xC2;\x11a\x01RW\x80cR\xD1\x90-\x11a\x01-W\x80cR\xD1\x90-\x14a\x03\x8CW\x80ci\xCCj\x04\x14a\x03\xA0W\x80cqP\x18\xA6\x14a\x03\xB4W\x80c\x82nA\xFC\x14a\x03\xC8W_\x80\xFD[\x80c7\x8E\xC2;\x14a\x03\x1CW\x80cBm1\x94\x14a\x038W\x80cO\x1E\xF2\x86\x14a\x03yW_\x80\xFD[\x80c c\xD4\xF7\x11a\x01\x8DW\x80c c\xD4\xF7\x14a\x02\\W\x80c-R\xAA\xD6\x14a\x02{W\x80c/y\x88\x9D\x14a\x02\xA7W\x80c1=\xF7\xB1\x14a\x02\xE5W_\x80\xFD[\x80c\x01?\xA5\xFC\x14a\x01\xB3W\x80c\x02\xB5\x92\xF3\x14a\x01\xD4W\x80c\r\x8En,\x14a\x021W[_\x80\xFD[4\x80\x15a\x01\xBEW_\x80\xFD[Pa\x01\xD2a\x01\xCD6`\x04a!hV[a\x06\x85V[\0[4\x80\x15a\x01\xDFW_\x80\xFD[Pa\x01\xF3a\x01\xEE6`\x04a!\x81V[a\x078V[`@Qa\x02(\x94\x93\x92\x91\x90`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x84\x01R\x92\x16`@\x82\x01R``\x81\x01\x91\x90\x91R`\x80\x01\x90V[`@Q\x80\x91\x03\x90\xF3[4\x80\x15a\x02W_\x80\xFD[Pa\x01\xD2a\x06M6`\x04a!hV[a\x0C\x9FV[4\x80\x15a\x06]W_\x80\xFD[Pa\x01\xD2a\x06l6`\x04a&\x80V[a\x0C\xE1V[4\x80\x15a\x06|W_\x80\xFD[P`\tTa\x03*V[a\x06\x8Da\r\x8CV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x06\xB4W`@Qc\xE6\xC4${`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08T`\x01`\x01`\xA0\x1B\x03\x90\x81\x16\x90\x82\x16\x03a\x06\xE3W`@Qc\xA8c\xAE\xC9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x80\x17\xBB\x88\x7F\xDF\x8F\xCAC\x14\xA9\xD4\x0Fns\xB3\xB8\x10\x02\xD6~\\\xFA\x85\xD8\x81s\xAFj\xA4`r\x90` \x01[`@Q\x80\x91\x03\x90\xA1PV[`\t\x81\x81T\x81\x10a\x07GW_\x80\xFD[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01\x80T`\x01\x90\x91\x01T`\x01`\x01`@\x1B\x03\x80\x83\x16\x93P`\x01`@\x1B\x83\x04\x81\x16\x92`\x01`\x80\x1B\x90\x04\x16\x90\x84V[`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15\x15\x80\x15a\x07\xA6WP`\x08T`\x01`\x01`\xA0\x1B\x03\x163\x14\x15[\x15a\x07\xC4W`@Qc\x01GL\x8F`\xE7\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x06T\x82Q`\x01`\x01`@\x1B\x03\x91\x82\x16\x91\x16\x11\x15\x80a\x07\xFDWP`\x06T` \x83\x01Q`\x01`\x01`@\x1B\x03`\x01`@\x1B\x90\x92\x04\x82\x16\x91\x16\x11\x15[\x15a\x08\x1BW`@Qc\x05\x1CF\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x08(\x82`@\x01Qa\r\xE7V[a\x082\x82\x82a\x0EWV[\x81Q`\x06\x80T` \x85\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x92\x16\x93\x16\x92\x90\x92\x17\x91\x90\x91\x17\x90U`@\x82\x01Q`\x07Ua\x08\x7Fa\x08xC\x90V[B\x84a\x0FKV[\x81` \x01Q`\x01`\x01`@\x1B\x03\x16\x82_\x01Q`\x01`\x01`@\x1B\x03\x16\x7F\xA0Jw9$PZA\x85d67%\xF5h2\xF5w.k\x8D\r\xBDn\xFC\xE7$\xDF\xE8\x03\xDA\xE6\x84`@\x01Q`@Qa\x08\xCF\x91\x81R` \x01\x90V[`@Q\x80\x91\x03\x90\xA3PPV[a\x08\xE3a\x114V[a\x08\xEC\x82a\x11\xD8V[a\x08\xF6\x82\x82a\x12\x19V[PPV[_a\t\x03a\x12\xDAV[P_\x80Q` a,\x90\x839\x81Q\x91R\x90V[a\t\x1Da\r\x8CV[`\x08T`\x01`\x01`\xA0\x1B\x03\x16\x15a\thW`\x08\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90U`@Q\x7F\x9A_W\xDE\x85m\xD6h\xC5M\xD9^\\U\xDF\x93C!q\xCB\xCAI\xA8wmV \xEAY\xC0$P\x90_\x90\xA1V[`@Qc\xA8c\xAE\xC9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[V[a\t\x8Ba\r\x8CV[a\t\x81_a\x13#V[`\t\x80T_\x91\x82\x91\x90a\t\xA8`\x01\x83a'\x82V[\x81T\x81\x10a\t\xB8Wa\t\xB8a'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x80\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x84\x10a\t\xF7W`@Qc\x18V\xA4\x99`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16[\x81\x81\x10\x15a\n\xB8W\x84`\t\x82\x81T\x81\x10a\n'Wa\n'a'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x80\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x11\x15a\n\xB0W`\t\x81\x81T\x81\x10a\n`Wa\n`a'\x95V[\x90_R` _ \x90`\x02\x02\x01`\x01\x01T`\t\x82\x81T\x81\x10a\n\x83Wa\n\x83a'\x95V[\x90_R` _ \x90`\x02\x02\x01_\x01`\x10\x90T\x90a\x01\0\n\x90\x04`\x01`\x01`@\x1B\x03\x16\x93P\x93PPP\x91P\x91V[`\x01\x01a\n\x0BV[PP\x91P\x91V[a\n\xC7a\r\x8CV[a\x0E\x10\x81c\xFF\xFF\xFF\xFF\x16\x10\x80a\n\xE6WPc\x01\xE13\x80\x81c\xFF\xFF\xFF\xFF\x16\x11[\x80a\x0B\x04WP`\x08Tc\xFF\xFF\xFF\xFF`\x01`\xA0\x1B\x90\x91\x04\x81\x16\x90\x82\x16\x11\x15[\x15a\x0B\"W`@Qc\x07\xA5\x07w`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x08\x80Tc\xFF\xFF\xFF\xFF\x90\x92\x16`\x01`\xA0\x1B\x02c\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90`\x01`\x01`@\x1B\x03\x16_\x81\x15\x80\x15a\x0B\x8CWP\x82[\x90P_\x82`\x01`\x01`@\x1B\x03\x16`\x01\x14\x80\x15a\x0B\xA7WP0;\x15[\x90P\x81\x15\x80\x15a\x0B\xB5WP\x80\x15[\x15a\x0B\xD3W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x0B\xFDW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[a\x0C\x06\x86a\x13\x93V[a\x0C\x0Ea\x13\xA4V[a\x0C\x19\x89\x89\x89a\x13\xACV[\x83\x15a\x0C_W\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPPPPPV[`\nT_\x90`\xFF\x16a\x0C\x85Wa\x0C\x80\x83\x83a\x14\xD8V[a\x0C\x96V[\x81`\x0BT\x84a\x0C\x94\x91\x90a'\x82V[\x11[\x90P[\x92\x91PPV[a\x0C\xA7a\r\x8CV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x0C\xD5W`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x0C\xDE\x81a\x13#V[PV[a\x0C\xEC`\t_a\x1E\x82V[_[\x81Q\x81\x10\x15a\x08\xF6W`\t\x82\x82\x81Q\x81\x10a\r\x0BWa\r\x0Ba'\x95V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q\x82T`\x01\x81\x81\x01\x85U_\x94\x85R\x93\x83\x90 \x82Q`\x02\x90\x92\x02\x01\x80T\x93\x83\x01Q`@\x84\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`\x80\x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x80\x1B\x19\x92\x82\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x97\x16\x91\x90\x94\x16\x17\x94\x90\x94\x17\x93\x90\x93\x16\x17\x82U``\x01Q\x90\x82\x01U\x01a\x0C\xEEV[3a\r\xBE\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14a\t\x81W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x0C\xCCV[\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\x81\x10\x80a\x08\xF6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FBn254: invalid scalar field\0\0\0\0\0`D\x82\x01R`d\x01a\x0C\xCCV[_a\x0E`a\x160V[\x90Pa\x0Eja\x1E\xA0V[\x83Q`\x01`\x01`@\x1B\x03\x90\x81\x16\x82R` \x85\x01Q\x16\x81`\x01` \x02\x01R`@\x84\x81\x01Q\x82\x82\x01R`\x01T``\x83\x01R`\x02T`\x80\x83\x01R`\x03T`\xA0\x83\x01R_T`\xC0\x83\x01RQc\xCESzw`\xE0\x1B\x81Rs_\xBD\xB21Vx\xAF\xEC\xB3g\xF02\xD9?d/d\x18\n\xA3\x90c\xCESzw\x90a\x0E\xE9\x90\x85\x90\x85\x90\x88\x90`\x04\x01a)\xAFV[` `@Q\x80\x83\x03\x81\x86Z\xF4\x15\x80\x15a\x0F\x04W=_\x80>=_\xFD[PPPP`@Q=`\x1F\x19`\x1F\x82\x01\x16\x82\x01\x80`@RP\x81\x01\x90a\x0F(\x91\x90a+\xDDV[a\x0FEW`@Qc\t\xBD\xE39`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[PPPPV[`\tT\x15\x80\x15\x90a\x0F\xC0WP`\x08T`\t\x80T`\x01`\xA0\x1B\x83\x04c\xFF\xFF\xFF\xFF\x16\x92`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0F\x8BWa\x0F\x8Ba'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01Ta\x0F\xB5\x90`\x01`@\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x84a+\xFCV[`\x01`\x01`@\x1B\x03\x16\x11[\x15a\x10SW`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x0F\xEDWa\x0F\xEDa'\x95V[_\x91\x82R` \x82 `\x02\x90\x91\x02\x01\x80T`\x01`\x01`\xC0\x1B\x03\x19\x16\x81U`\x01\x01U`\x08\x80T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90`\x18a\x10-\x83a,#V[\x91\x90a\x01\0\n\x81T\x81`\x01`\x01`@\x1B\x03\x02\x19\x16\x90\x83`\x01`\x01`@\x1B\x03\x16\x02\x17\x90UPP[`@\x80Q`\x80\x81\x01\x82R`\x01`\x01`@\x1B\x03\x94\x85\x16\x81R\x92\x84\x16` \x80\x85\x01\x91\x82R\x83\x01Q\x85\x16\x84\x83\x01\x90\x81R\x92\x90\x91\x01Q``\x84\x01\x90\x81R`\t\x80T`\x01\x81\x01\x82U_\x91\x90\x91R\x93Q`\x02\x90\x94\x02\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xAF\x81\x01\x80T\x93Q\x94Q\x87\x16`\x01`\x80\x1B\x02g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\x80\x1B\x19\x95\x88\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x90\x95\x16\x96\x90\x97\x16\x95\x90\x95\x17\x92\x90\x92\x17\x92\x90\x92\x16\x93\x90\x93\x17\x90\x91UQ\x7Fn\x15@\x17\x1Bl\x0C\x96\x0Bq\xA7\x02\r\x9F`\x07\x7Fj\xF91\xA8\xBB\xF5\x90\xDA\x02#\xDA\xCFu\xC7\xB0\x90\x91\x01UV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14\x80a\x11\xBAWP\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0`\x01`\x01`\xA0\x1B\x03\x16a\x11\xAE_\x80Q` a,\x90\x839\x81Q\x91RT`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x14\x15[\x15a\t\x81W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x11\xE0a\r\x8CV[`@Q`\x01`\x01`\xA0\x1B\x03\x82\x16\x81R\x7F\xF7\x87!\"n\xFE\x9A\x1B\xB6x\x18\x9A\x16\xD1UI(\xB9\xF2\x19.,\xB9>\xED\xA8;y\xFA@\0}\x90` \x01a\x07-V[\x81`\x01`\x01`\xA0\x1B\x03\x16cR\xD1\x90-`@Q\x81c\xFF\xFF\xFF\xFF\x16`\xE0\x1B\x81R`\x04\x01` `@Q\x80\x83\x03\x81\x86Z\xFA\x92PPP\x80\x15a\x12sWP`@\x80Q`\x1F=\x90\x81\x01`\x1F\x19\x16\x82\x01\x90\x92Ra\x12p\x91\x81\x01\x90a,HV[`\x01[a\x12\x9BW`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[_\x80Q` a,\x90\x839\x81Q\x91R\x81\x14a\x12\xCBW`@Qc*\x87Ri`\xE2\x1B\x81R`\x04\x81\x01\x82\x90R`$\x01a\x0C\xCCV[a\x12\xD5\x83\x83a\x1C`V[PPPV[0`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\t\x81W`@Qcp>F\xDD`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x7F\x90\x16\xD0\x9Dr\xD4\x0F\xDA\xE2\xFD\x8C\xEA\xC6\xB6#Lw\x06!O\xD3\x9C\x1C\xD1\xE6\t\xA0R\x8C\x19\x93\0\x80T`\x01`\x01`\xA0\x1B\x03\x19\x81\x16`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x91\x82\x17\x84U`@Q\x92\x16\x91\x82\x90\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x90_\x90\xA3PPPV[a\x13\x9Ba\x1C\xB5V[a\x0C\xDE\x81a\x1C\xFEV[a\t\x81a\x1C\xB5V[\x82Q`\x01`\x01`@\x1B\x03\x16\x15\x15\x80a\x13\xD0WP` \x83\x01Q`\x01`\x01`@\x1B\x03\x16\x15\x15[\x80a\x13\xDDWP` \x82\x01Q\x15[\x80a\x13\xEAWP`@\x82\x01Q\x15[\x80a\x13\xF7WP``\x82\x01Q\x15[\x80a\x14\x01WP\x81Q\x15[\x80a\x14\x13WPa\x0E\x10\x81c\xFF\xFF\xFF\xFF\x16\x10[\x80a\x14'WPc\x01\xE13\x80\x81c\xFF\xFF\xFF\xFF\x16\x11[\x15a\x14EW`@QcP\xDD\x03\xF7`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x82Q`\x04\x80T` \x80\x87\x01Q`\x01`\x01`@\x1B\x03\x90\x81\x16`\x01`@\x1B\x02`\x01`\x01`\x80\x1B\x03\x19\x93\x84\x16\x91\x90\x95\x16\x90\x81\x17\x85\x17\x90\x93U`@\x96\x87\x01Q`\x05\x81\x90U\x86Q_U\x90\x86\x01Q`\x01U\x95\x85\x01Q`\x02U``\x90\x94\x01Q`\x03U`\x06\x80T\x90\x94\x16\x17\x17\x90\x91U`\x07\x91\x90\x91U`\x08\x80Tc\xFF\xFF\xFF\xFF\x90\x92\x16`\x01`\xA0\x1B\x02c\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x90\x92\x16\x91\x90\x91\x17\x90UV[`\tT_\x90C\x84\x11\x80a\x14\xE9WP\x80\x15[\x80a\x153WP`\x08T`\t\x80T\x90\x91`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x90\x81\x10a\x15\x17Wa\x15\x17a'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x84\x10[\x15a\x15QW`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x80\x80a\x15_`\x01\x85a'\x82V[\x90P[\x81a\x15\xFBW`\x08T`\x01`\xC0\x1B\x90\x04`\x01`\x01`@\x1B\x03\x16\x81\x10a\x15\xFBW\x86`\t\x82\x81T\x81\x10a\x15\x94Wa\x15\x94a'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x11a\x15\xE9W`\x01\x91P`\t\x81\x81T\x81\x10a\x15\xC9Wa\x15\xC9a'\x95V[_\x91\x82R` \x90\x91 `\x02\x90\x91\x02\x01T`\x01`\x01`@\x1B\x03\x16\x92Pa\x15\xFBV[\x80a\x15\xF3\x81a,_V[\x91PPa\x15bV[\x81a\x16\x19W`@Qc\xB0\xB48w`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x85a\x16$\x84\x89a'\x82V[\x11\x97\x96PPPPPPPV[a\x168a\x1E\xBEV[b\x01\0\0\x81R`\x07` \x82\x01R\x7F\x13i\xAAx\xDCP\x13Z\xD7V\xD6,\x97\xA6J\x0E\xDC\xD3\0fXAh \r\x9D\x1F\xAC\xF8,\xA4\xF5`@\x82\x01QR\x7F,\xF24V\xD7\x12\xB0o\x8E:\xA5\xBF\n\xCC>F\xA3\xD0\x94`*:+\x99\xD8s\xBB\xA0ZC\x91G` `@\x83\x01Q\x01R\x7F\x08\xA3_7\x9D-,I\nQ\0f\x97'^M\xB7\x9Bg\xB4\xA1u\xC1G~&-)\xE2^B1``\x82\x01QR\x7F!\x88(\x13\x1B\xB7\x94\x0C\xCC\x88\xC5a\xB2\x99uZ\xF4\xBF\x0Bq\xED\x93\x0B\x12\x9E\x8B\xE0\xA1!\x819\xEA` ``\x83\x01Q\x01R\x7F#\xA2\x17$6\xC1\x14[6\xD5\xBCm;1\xFA\x16\x10\xC7:T>\xA4C\x91\x8A\xAA>\xE1u\xF9\x92\x1B`\x80\x82\x01QR\x7F%\x02\xAD\xF4\x04\xD6(w\xC3\x10!J\xE9\x94.\x93\xC4\x0B\x15M4\xC0$\xBA\xB4\x8A<\xA0W\xE6\n\x11` `\x80\x83\x01Q\x01R\x7F\x1B\xB8\x8A\xDA\x91\xABw4\x88/x&\xB8\x12u2\0\x81\xACH_\x9C\xF8\xBF\xBC;\xA5Kn\xB4\xDF\xF3`\xA0\x82\x01QR\x7F%\xC7J'\xE9\xA3\xB2\x01\x14\xA3\xA9\x1F1\xC2\x0F\x01w~~\xD9\x13\xE0\xEF\x94\x9F\x02\x85\xE2\xE7\xC2\x06\x9B` `\xA0\x83\x01Q\x01R\x7F\x12\xB0\xCEv\xAC\x8B\r\xBD@^\xBC]\xD0\xBA\xE0\xF9\x1A\xEDP\x03<~\xA3o\xC6*\xAB\xA2\xB9\x833\xDC`\xC0\x82\x01QR\x7F\x18[B\xAFI\xDD\x1C\xBE3z\x84\xF7KpArB\x8EuJ\x0B\xEA\x02J\xB3\xEB/\x99j\xFB,G` `\xC0\x83\x01Q\x01R\x7F!\xF5:\xD4S\x8BEC\x8B\xBF\x05!D`p\"9 \xE3\xDFo\x90\"\xA6L\xC1m\x7F\x94\xE8\\\x08`\xE0\x82\x01QR\x7F\"x\xAC=\xED\xFD\xAC\x7F\xEB\x97%\xA0\"IquQ\x8E\xAD\xA5,\x892\xFC@\xE6\xE7[\xEA\x88\x9F\xB8` `\xE0\x83\x01Q\x01R\x7F\x08v\x13o\x81\xC1b\x98H{\xFB\x1B\xE7MJ4\x87\xECEdZ\xB1\xD0\x9D\xC2\xE5\xB8e\xD6\"0\xDFa\x01\0\x82\x01QR\x7F\t\x8Cd\x1C\x94~\xCDy\x8D\xFD^\x1B/\xE4(\x02L\xDF\x03\x06\x1AS\xFFwN\xA8\xA9\xE3\xDE\x9D?+` a\x01\0\x83\x01Q\x01R\x7F\x15\xEA\xAC,b2\xD2&\x8B\xF7\x9D\xC4~\xD9fo\x99/\xB3\xD9j\xD2?\xB2\x16\x90\xC2\x15\x86\xC5G.a\x01 \x82\x01QR\x7F\x0F\x10\xF1\xFF\xC5H\x81(\x7F\xDAo \x0B\xC8]\x82E\xB5\x08\xD8D\xA9t\t\x8AA\x11\x98g\xB3%\xD0` a\x01 \x83\x01Q\x01R\x7F\x08\x95\xCE\xEA@\xB0\x85SN\x979\xCATB\xBAH\xB3\xA3Y*\xFF\xDE+P\x9D\xF7E!\xB4}\x8A\xB0a\x01@\x82\x01QR\x7F.\x12\xECX\0\xAC\x92\xFE*\x8Ep@\xBC[C[\x9E\xB7\x1E18\x01s\xFAv\x88\xBF\x81\xFC\xBB\xA4U` a\x01@\x83\x01Q\x01R\x7F/S\x84\xEBVS\xE4uv\xEF\xE2H\xE7\x90?F2CAK\xFE\xD5#}\xDAu\r\xF3\x99k\xD9\x18a\x01`\x82\x01QR\x7F\x1C<\xD6\xB1\x1D\xA8pL\xDC\x87\x1A\xB4\xFA2=~\xE5{\xD4\x0C\xE1e\xB4\x9AV\xD5\xEFd\x89\xCD%\x1A` a\x01`\x83\x01Q\x01R\x7F\x13W\x99\x94\x95|\xE1UL\xC1\xE5\xB1\x94\xFBc\xC9Q7\x07\xF6'AO\x84Bh\x1A\xE76\xE3dPa\x01\x80\x82\x01QR\x7F&\xC9\xBD\xCD\x96\xD8\xE4 \xB1)t\xAD\xE9:\xD9\xC3\x12\xC4\x18R\x13\xD2\xF6\x83\x1A|bZ\x18\x89\x0E\x95` a\x01\x80\x83\x01Q\x01R\x7F\x0C\xC7\n\x1DT*\x9A\x155\xAE]\x92\x01ij\xDC\\\x99\xC1\xBC\xEB\xD9\x95\x1D\xFA\x8A\xFE\xC7\x9F\xA0\xB6Da\x01\xA0\x82\x01QR\x7F\x10\xB0C\xD9\xF1\x86\x91\x81\xB9ey\xD6an\xFC\x17\xA5\xDF{\x84\xC4\xD41\xD9f\xC9\tK\xF1\xE8\x81S` a\x01\xA0\x83\x01Q\x01R\x7F\x19\x8Ae0\x9D\x13\x1AC\xB0\xAB\x1CGe\x9D\x036\xCF\xBFb\xB2\x7FG'\x10kO\xD9q\xC7=\xD4\x03a\x01\xC0\x82\x01QR\x7F#\xDF\x99\xEA\xC3\xC1\x94y\x03\xB2\x11\xB8\0\xEF\xEBv\xF4}^\x87\xB7AHfT4\x92\xE8\xC7y\x8D\x1A` a\x01\xC0\x83\x01Q\x01R\x7F\"\x1C\xC5\xE4{\x81\xCE\x8D\xCF\xA7.\xF9\x81\x91j\x8E\xDD\xEF\x12\xFC\xDEY\xC5lb\x83\x0C\x12n\xBE\xF0\xDEa\x01\xE0\x82\x01QR\x7F#\x1F\x994\x0C5\xC9\xE0\x96R\xA6\xDFs\xC9\xCE\xC5\xD8\x878\xCBq\xFFEqo\xDC\x9E\x9EE\xA4\x92n` a\x01\xE0\x83\x01Q\x01R\x7F,\x9F\x14\x89\xFC\xE0\xF2c\xE0?>\x97\xBF\nr':\xAF\xCC\xA92_\xF4w\x86\xAD\xB0JR\xA6\xD2,a\x02\0\x82\x01QR\x7F!\xF6n(\xF1~\x01\xE9\xFDY>\x16\xD0\"\xC4\xEC\xA2[\xD5\xDB\x96\xDA\xEC`m\x97\xB6\x04\xCCAH8` a\x02\0\x83\x01Q\x01R\x7F \x15tV\x04\xA9W\x1E\"k\xD9\x90C\xCF\xAF\x1F\x96&|\xC5\xDEg\xF4\x97V?\xF8\x11\0S\x1D&a\x02 \x82\x01QR\x7F h\x89\xFFLX\xDD\x08\xEE\x11\x07\x19\x1A*[\xC5\xDB\xAEU\xC4\x9D}\x83\x97\x80\x17\x99\x86\x8D\x10\xF8\x05` a\x02 \x83\x01Q\x01R\x7F!\x06*\xB8\xF8\xEC\xD8\x93+B\x9A\x1E\xB8aK\x1E\x03\xDBa\xBF\xF6\xA5\xCD-]~\xA1\x93\xE9\x0E\x99'a\x02@\x82\x01QR\x7F!\x7F\x9B'\xB94\xB8\x8F\xFEU]h-\xFEn\x8BmP?\x86\xB1K\xBD\x964+\xC4\x84\x87\xA6\x0B'` a\x02@\x83\x01Q\x01R\x7F\x1C\x9E\xDA-\x19\\\xB71\xF9\x03#^\xADjO|f\xDBI\xDAq>\xCB'\xAF\xEE\x07o\x0E\xEAqTa\x02`\x82\x01QR\x7F&G\xC1a\xC0\x0B\x90%\x8E\x1C\xEF\xEB\xB1t\x81\xF8\xA5\xD9\x1B_\x9D\xCAbn>\x89\xA9![\xCC\xA1j` a\x02`\x83\x01Q\x01R\x7F\xB0\x83\x88\x93\xEC\x1F#~\x8B\x072;\x07DY\x9FN\x97\xB5\x98\xB3\xB5\x89\xBC\xC2\xBC7\xB8\xD5\xC4\x18\x01a\x02\x80\x82\x01R\x7F\xC1\x83\x93\xC0\xFA0\xFEN\x8B\x03\x8E5z\xD8Q\xEA\xE8\xDE\x91\x07XN\xFF\xE7\xC7\xF1\xF6Q\xB2\x01\x0E&a\x02\xA0\x82\x01R\x90V[a\x1Ci\x82a\x1D\x06V[`@Q`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBC|\xD7Z \xEE'\xFD\x9A\xDE\xBA\xB3 A\xF7U!M\xBCk\xFF\xA9\x0C\xC0\"[9\xDA.\\-;\x90_\x90\xA2\x80Q\x15a\x1C\xADWa\x12\xD5\x82\x82a\x1DiV[a\x08\xF6a\x1D\xDBV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0T`\x01`@\x1B\x90\x04`\xFF\x16a\t\x81W`@Qc\x1A\xFC\xD7\x9F`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0C\xA7a\x1C\xB5V[\x80`\x01`\x01`\xA0\x1B\x03\x16;_\x03a\x1D;W`@QcL\x9C\x8C\xE3`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x82\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[_\x80Q` a,\x90\x839\x81Q\x91R\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x91\x90\x91\x17\x90UV[``_\x80\x84`\x01`\x01`\xA0\x1B\x03\x16\x84`@Qa\x1D\x85\x91\x90a,tV[_`@Q\x80\x83\x03\x81\x85Z\xF4\x91PP=\x80_\x81\x14a\x1D\xBDW`@Q\x91P`\x1F\x19`?=\x01\x16\x82\x01`@R=\x82R=_` \x84\x01>a\x1D\xC2V[``\x91P[P\x91P\x91Pa\x1D\xD2\x85\x83\x83a\x1D\xFAV[\x95\x94PPPPPV[4\x15a\t\x81W`@Qc\xB3\x98\x97\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[``\x82a\x1E\x0FWa\x1E\n\x82a\x1EYV[a\x1ERV[\x81Q\x15\x80\x15a\x1E&WP`\x01`\x01`\xA0\x1B\x03\x84\x16;\x15[\x15a\x1EOW`@Qc\x99\x96\xB3\x15`\xE0\x1B\x81R`\x01`\x01`\xA0\x1B\x03\x85\x16`\x04\x82\x01R`$\x01a\x0C\xCCV[P\x80[\x93\x92PPPV[\x80Q\x15a\x1EiW\x80Q\x80\x82` \x01\xFD[`@Qc\n\x12\xF5!`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[P\x80T_\x82U`\x02\x02\x90_R` _ \x90\x81\x01\x90a\x0C\xDE\x91\x90a!$V[`@Q\x80`\xE0\x01`@R\x80`\x07\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[`@Q\x80a\x02\xC0\x01`@R\x80_\x81R` \x01_\x81R` \x01a\x1E\xF1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\x11`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1FQ`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1Fq`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\x91`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\xB1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\xD1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a\x1F\xF1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a \x11`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a 1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a Q`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a q`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a \x91`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a \xB1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a \xD1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a \xF1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R` \x01a!\x11`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[\x81R_` \x82\x01\x81\x90R`@\x90\x91\x01R\x90V[[\x80\x82\x11\x15a!IW\x80T`\x01`\x01`\xC0\x1B\x03\x19\x16\x81U_`\x01\x82\x01U`\x02\x01a!%V[P\x90V[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a!cW_\x80\xFD[\x91\x90PV[_` \x82\x84\x03\x12\x15a!xW_\x80\xFD[a\x0C\x96\x82a!MV[_` \x82\x84\x03\x12\x15a!\x91W_\x80\xFD[P5\x91\x90PV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Qa\x02\xE0\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a!\xCFWa!\xCFa!\x98V[`@R\x90V[`@Q`\x80\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a!\xCFWa!\xCFa!\x98V[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\"\x1FWa\"\x1Fa!\x98V[`@R\x91\x90PV[\x805`\x01`\x01`@\x1B\x03\x81\x16\x81\x14a!cW_\x80\xFD[_``\x82\x84\x03\x12\x15a\"MW_\x80\xFD[`@Q``\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\"oWa\"oa!\x98V[`@R\x90P\x80a\"~\x83a\"'V[\x81Ra\"\x8C` \x84\x01a\"'V[` \x82\x01R`@\x83\x015`@\x82\x01RP\x92\x91PPV[_`@\x82\x84\x03\x12\x15a\"\xB2W_\x80\xFD[`@Q`@\x81\x01\x81\x81\x10`\x01`\x01`@\x1B\x03\x82\x11\x17\x15a\"\xD4Wa\"\xD4a!\x98V[`@R\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x80\x82\x84\x03a\x04\xE0\x81\x12\x15a#\x01W_\x80\xFD[a#\x0B\x85\x85a\"=V[\x92Pa\x04\x80\x80`_\x19\x83\x01\x12\x15a# W_\x80\xFD[a#(a!\xACV[\x91Pa#7\x86``\x87\x01a\"\xA2V[\x82Ra#F\x86`\xA0\x87\x01a\"\xA2V[` \x83\x01Ra#X\x86`\xE0\x87\x01a\"\xA2V[`@\x83\x01Ra\x01 a#l\x87\x82\x88\x01a\"\xA2V[``\x84\x01Ra\x01`a#\x80\x88\x82\x89\x01a\"\xA2V[`\x80\x85\x01Ra\x01\xA0a#\x94\x89\x82\x8A\x01a\"\xA2V[`\xA0\x86\x01Ra\x01\xE0a#\xA8\x8A\x82\x8B\x01a\"\xA2V[`\xC0\x87\x01Ra\x02 a#\xBC\x8B\x82\x8C\x01a\"\xA2V[`\xE0\x88\x01Ra\x02`a#\xD0\x8C\x82\x8D\x01a\"\xA2V[a\x01\0\x89\x01Ra\x02\xA0a#\xE5\x8D\x82\x8E\x01a\"\xA2V[\x87\x8A\x01Ra#\xF7\x8Da\x02\xE0\x8E\x01a\"\xA2V[a\x01@\x8A\x01Ra$\x0B\x8Da\x03 \x8E\x01a\"\xA2V[\x86\x8A\x01Ra$\x1D\x8Da\x03`\x8E\x01a\"\xA2V[a\x01\x80\x8A\x01Ra\x03\xA0\x8C\x015\x94\x89\x01\x94\x90\x94Ra\x03\xC0\x8B\x015a\x01\xC0\x89\x01Ra\x03\xE0\x8B\x015\x92\x88\x01\x92\x90\x92Ra\x04\0\x8A\x015a\x02\0\x88\x01Ra\x04 \x8A\x015\x90\x87\x01Ra\x04@\x89\x015a\x02@\x87\x01Ra\x04`\x89\x015\x90\x86\x01R\x92\x87\x015a\x02\x80\x85\x01RPPa\x04\xA0\x85\x015\x90\x82\x01Ra\x04\xC0\x90\x93\x015a\x02\xC0\x84\x01RP\x92\x90\x91PV[_\x80`@\x83\x85\x03\x12\x15a$\xB0W_\x80\xFD[a$\xB9\x83a!MV[\x91P` \x80\x84\x015`\x01`\x01`@\x1B\x03\x80\x82\x11\x15a$\xD5W_\x80\xFD[\x81\x86\x01\x91P\x86`\x1F\x83\x01\x12a$\xE8W_\x80\xFD[\x815\x81\x81\x11\x15a$\xFAWa$\xFAa!\x98V[a%\x0C`\x1F\x82\x01`\x1F\x19\x16\x85\x01a!\xF7V[\x91P\x80\x82R\x87\x84\x82\x85\x01\x01\x11\x15a%!W_\x80\xFD[\x80\x84\x84\x01\x85\x84\x017_\x84\x82\x84\x01\x01RP\x80\x93PPPP\x92P\x92\x90PV[\x805c\xFF\xFF\xFF\xFF\x81\x16\x81\x14a!cW_\x80\xFD[_` \x82\x84\x03\x12\x15a%aW_\x80\xFD[a\x0C\x96\x82a%>V[_\x80_\x80\x84\x86\x03a\x01 \x81\x12\x15a%\x7FW_\x80\xFD[a%\x89\x87\x87a\"=V[\x94P`\x80`_\x19\x82\x01\x12\x15a%\x9CW_\x80\xFD[Pa%\xA5a!\xD5V[``\x86\x81\x015\x82R`\x80\x87\x015` \x83\x01R`\xA0\x87\x015`@\x83\x01R`\xC0\x87\x015\x90\x82\x01R\x92Pa%\xD8`\xE0\x86\x01a%>V[\x91Pa%\xE7a\x01\0\x86\x01a!MV[\x90P\x92\x95\x91\x94P\x92PV[_[\x83\x81\x10\x15a&\x0CW\x81\x81\x01Q\x83\x82\x01R` \x01a%\xF4V[PP_\x91\x01RV[` \x81R_\x82Q\x80` \x84\x01Ra&2\x81`@\x85\x01` \x87\x01a%\xF2V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[_``\x82\x84\x03\x12\x15a&VW_\x80\xFD[a\x0C\x96\x83\x83a\"=V[_\x80`@\x83\x85\x03\x12\x15a&qW_\x80\xFD[PP\x805\x92` \x90\x91\x015\x91PV[_` \x80\x83\x85\x03\x12\x15a&\x91W_\x80\xFD[\x825`\x01`\x01`@\x1B\x03\x80\x82\x11\x15a&\xA7W_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a&\xBAW_\x80\xFD[\x815\x81\x81\x11\x15a&\xCCWa&\xCCa!\x98V[a&\xDA\x84\x82`\x05\x1B\x01a!\xF7V[\x81\x81R\x84\x81\x01\x92P`\x07\x91\x90\x91\x1B\x83\x01\x84\x01\x90\x87\x82\x11\x15a&\xF9W_\x80\xFD[\x92\x84\x01\x92[\x81\x84\x10\x15a'cW`\x80\x84\x89\x03\x12\x15a'\x15W_\x80\xFD[a'\x1Da!\xD5V[a'&\x85a\"'V[\x81Ra'3\x86\x86\x01a\"'V[\x86\x82\x01R`@a'D\x81\x87\x01a\"'V[\x90\x82\x01R``\x85\x81\x015\x90\x82\x01R\x83R`\x80\x90\x93\x01\x92\x91\x84\x01\x91a&\xFEV[\x97\x96PPPPPPPV[cNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x0C\x99Wa\x0C\x99a'nV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x80_[`\x07\x81\x10\x15a\x0FEW\x81Q\x84R` \x93\x84\x01\x93\x90\x91\x01\x90`\x01\x01a'\xACV[a'\xE0\x82\x82Q\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[` \x81\x81\x01Q\x80Q`@\x85\x01R\x90\x81\x01Q``\x84\x01RP`@\x81\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP``\x81\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\x80\x81\x01Qa\x01\0a(C\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xA0\x83\x01Q\x91Pa\x01@a(c\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x84\x01Q\x92Pa\x01\x80a(\x83\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x85\x01Q\x93Pa\x01\xC0a(\xA3\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x85\x01Q\x93Pa\x02\0\x92a(\xC3\x87\x85\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x86\x01Q\x94Pa\x02@a(\xE4\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x86\x01Q\x94Pa\x02\x80\x92a)\x04\x88\x85\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x87\x01Q\x95Pa\x02\xC0a)%\x81\x8A\x01\x88\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x92\x87\x01Q\x80Qa\x03\0\x8A\x01R` \x01Qa\x03 \x89\x01Ra\x01\xA0\x87\x01Qa\x03@\x89\x01R\x90\x86\x01Qa\x03`\x88\x01Ra\x01\xE0\x86\x01Qa\x03\x80\x88\x01R\x92\x85\x01Qa\x03\xA0\x87\x01Ra\x02 \x85\x01Qa\x03\xC0\x87\x01R\x91\x84\x01Qa\x03\xE0\x86\x01Ra\x02`\x84\x01Qa\x04\0\x86\x01R\x83\x01Qa\x04 \x85\x01Ra\x02\xA0\x83\x01Qa\x04@\x85\x01R\x90\x91\x01Qa\x04`\x90\x92\x01\x91\x90\x91RPV[_a\n`\x82\x01\x90P\x84Q\x82R` \x85\x01Q` \x83\x01R`@\x85\x01Qa)\xE1`@\x84\x01\x82\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[P``\x85\x01Q\x80Q`\x80\x84\x01R` \x81\x01Q`\xA0\x84\x01RP`\x80\x85\x01Q\x80Q`\xC0\x84\x01R` \x81\x01Q`\xE0\x84\x01RP`\xA0\x85\x01Qa\x01\0a*.\x81\x85\x01\x83\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xC0\x87\x01Q\x91Pa\x01@a*N\x81\x86\x01\x84\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[`\xE0\x88\x01Q\x92Pa\x01\x80a*n\x81\x87\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x88\x01Q\x92Pa\x01\xC0\x91a*\x8E\x86\x84\x01\x85\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01 \x89\x01Q\x93Pa\x02\0a*\xAF\x81\x88\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x89\x01Q\x93Pa\x02@\x91a*\xCF\x87\x84\x01\x86\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[a\x01`\x8A\x01Q\x94Pa\x02\x80a*\xF0\x81\x89\x01\x87\x80Q\x82R` \x90\x81\x01Q\x91\x01RV[\x91\x8A\x01Q\x80Qa\x02\xC0\x89\x01R` \x90\x81\x01Qa\x02\xE0\x89\x01Ra\x01\xA0\x8B\x01Q\x80Qa\x03\0\x8A\x01R\x81\x01Qa\x03 \x89\x01R\x93\x8A\x01Q\x80Qa\x03@\x89\x01R\x84\x01Qa\x03`\x88\x01Ra\x01\xE0\x8A\x01Q\x80Qa\x03\x80\x89\x01R\x84\x01Qa\x03\xA0\x88\x01R\x89\x01Q\x80Qa\x03\xC0\x88\x01R\x83\x01Qa\x03\xE0\x87\x01Ra\x02 \x89\x01Q\x80Qa\x04\0\x88\x01R\x83\x01Qa\x04 \x87\x01R\x90\x88\x01Q\x80Qa\x04@\x87\x01R\x82\x01Qa\x04`\x86\x01Ra\x02`\x88\x01Q\x80Qa\x04\x80\x87\x01R\x90\x91\x01Qa\x04\xA0\x85\x01R\x86\x01Qa\x04\xC0\x84\x01RPa\x02\xA0\x85\x01Qa\x04\xE0\x83\x01Ra+\xC7a\x05\0\x83\x01\x85a'\xA9V[a+\xD5a\x05\xE0\x83\x01\x84a'\xCBV[\x94\x93PPPPV[_` \x82\x84\x03\x12\x15a+\xEDW_\x80\xFD[\x81Q\x80\x15\x15\x81\x14a\x1ERW_\x80\xFD[`\x01`\x01`@\x1B\x03\x82\x81\x16\x82\x82\x16\x03\x90\x80\x82\x11\x15a,\x1CWa,\x1Ca'nV[P\x92\x91PPV[_`\x01`\x01`@\x1B\x03\x80\x83\x16\x81\x81\x03a,>Wa,>a'nV[`\x01\x01\x93\x92PPPV[_` \x82\x84\x03\x12\x15a,XW_\x80\xFD[PQ\x91\x90PV[_\x81a,mWa,ma'nV[P_\x19\x01\x90V[_\x82Qa,\x85\x81\x84` \x87\x01a%\xF2V[\x91\x90\x91\x01\x92\x91PPV\xFE6\x08\x94\xA1;\xA1\xA3!\x06g\xC8(I-\xB9\x8D\xCA> v\xCC75\xA9 \xA3\xCAP]8+\xBC\xA1dsolcC\0\x08\x17\0\n", ); /**Custom error with signature `AddressEmptyCode(address)` and selector `0x9996b315`. - ```solidity - error AddressEmptyCode(address target); - ```*/ +```solidity +error AddressEmptyCode(address target); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct AddressEmptyCode { @@ -3426,11 +3707,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3450,7 +3733,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for AddressEmptyCode { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "AddressEmptyCode(address)"; const SELECTOR: [u8; 4] = [153u8, 150u8, 179u8, 21u8]; #[inline] @@ -3470,9 +3755,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `ERC1967InvalidImplementation(address)` and selector `0x4c9c8ce3`. - ```solidity - error ERC1967InvalidImplementation(address implementation); - ```*/ +```solidity +error ERC1967InvalidImplementation(address implementation); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967InvalidImplementation { @@ -3493,33 +3778,37 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: ERC1967InvalidImplementation) -> Self { (value.implementation,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for ERC1967InvalidImplementation { + impl ::core::convert::From> + for ERC1967InvalidImplementation { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - implementation: tuple.0, - } + Self { implementation: tuple.0 } } } #[automatically_derived] impl alloy_sol_types::SolError for ERC1967InvalidImplementation { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967InvalidImplementation(address)"; const SELECTOR: [u8; 4] = [76u8, 156u8, 140u8, 227u8]; #[inline] @@ -3539,9 +3828,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `ERC1967NonPayable()` and selector `0xb398979f`. - ```solidity - error ERC1967NonPayable(); - ```*/ +```solidity +error ERC1967NonPayable(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ERC1967NonPayable {} @@ -3559,11 +3848,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3583,7 +3874,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for ERC1967NonPayable { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ERC1967NonPayable()"; const SELECTOR: [u8; 4] = [179u8, 152u8, 151u8, 159u8]; #[inline] @@ -3599,9 +3892,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `FailedInnerCall()` and selector `0x1425ea42`. - ```solidity - error FailedInnerCall(); - ```*/ +```solidity +error FailedInnerCall(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct FailedInnerCall {} @@ -3619,11 +3912,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3643,7 +3938,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for FailedInnerCall { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "FailedInnerCall()"; const SELECTOR: [u8; 4] = [20u8, 37u8, 234u8, 66u8]; #[inline] @@ -3659,9 +3956,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InsufficientSnapshotHistory()` and selector `0xb0b43877`. - ```solidity - error InsufficientSnapshotHistory(); - ```*/ +```solidity +error InsufficientSnapshotHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InsufficientSnapshotHistory {} @@ -3679,23 +3976,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InsufficientSnapshotHistory) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InsufficientSnapshotHistory { + impl ::core::convert::From> + for InsufficientSnapshotHistory { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3703,7 +4004,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InsufficientSnapshotHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InsufficientSnapshotHistory()"; const SELECTOR: [u8; 4] = [176u8, 180u8, 56u8, 119u8]; #[inline] @@ -3719,9 +4022,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidAddress()` and selector `0xe6c4247b`. - ```solidity - error InvalidAddress(); - ```*/ +```solidity +error InvalidAddress(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidAddress {} @@ -3739,11 +4042,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3763,7 +4068,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidAddress { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidAddress()"; const SELECTOR: [u8; 4] = [230u8, 196u8, 36u8, 123u8]; #[inline] @@ -3779,9 +4086,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidArgs()` and selector `0xa1ba07ee`. - ```solidity - error InvalidArgs(); - ```*/ +```solidity +error InvalidArgs(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidArgs {} @@ -3799,11 +4106,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3823,7 +4132,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidArgs { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidArgs()"; const SELECTOR: [u8; 4] = [161u8, 186u8, 7u8, 238u8]; #[inline] @@ -3839,9 +4150,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidHotShotBlockForCommitmentCheck()` and selector `0x615a9264`. - ```solidity - error InvalidHotShotBlockForCommitmentCheck(); - ```*/ +```solidity +error InvalidHotShotBlockForCommitmentCheck(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidHotShotBlockForCommitmentCheck {} @@ -3859,23 +4170,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: InvalidHotShotBlockForCommitmentCheck) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for InvalidHotShotBlockForCommitmentCheck { + impl ::core::convert::From> + for InvalidHotShotBlockForCommitmentCheck { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3883,7 +4198,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidHotShotBlockForCommitmentCheck { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidHotShotBlockForCommitmentCheck()"; const SELECTOR: [u8; 4] = [97u8, 90u8, 146u8, 100u8]; #[inline] @@ -3899,9 +4216,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`. - ```solidity - error InvalidInitialization(); - ```*/ +```solidity +error InvalidInitialization(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidInitialization {} @@ -3919,11 +4236,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3943,7 +4262,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidInitialization { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidInitialization()"; const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8]; #[inline] @@ -3959,9 +4280,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidMaxStateHistory()` and selector `0xf4a0eee0`. - ```solidity - error InvalidMaxStateHistory(); - ```*/ +```solidity +error InvalidMaxStateHistory(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidMaxStateHistory {} @@ -3979,11 +4300,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4003,7 +4326,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidMaxStateHistory { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidMaxStateHistory()"; const SELECTOR: [u8; 4] = [244u8, 160u8, 238u8, 224u8]; #[inline] @@ -4019,9 +4344,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `InvalidProof()` and selector `0x09bde339`. - ```solidity - error InvalidProof(); - ```*/ +```solidity +error InvalidProof(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidProof {} @@ -4039,11 +4364,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4063,7 +4390,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for InvalidProof { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidProof()"; const SELECTOR: [u8; 4] = [9u8, 189u8, 227u8, 57u8]; #[inline] @@ -4079,9 +4408,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `NoChangeRequired()` and selector `0xa863aec9`. - ```solidity - error NoChangeRequired(); - ```*/ +```solidity +error NoChangeRequired(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NoChangeRequired {} @@ -4099,11 +4428,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4123,7 +4454,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for NoChangeRequired { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NoChangeRequired()"; const SELECTOR: [u8; 4] = [168u8, 99u8, 174u8, 201u8]; #[inline] @@ -4139,9 +4472,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`. - ```solidity - error NotInitializing(); - ```*/ +```solidity +error NotInitializing(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NotInitializing {} @@ -4159,11 +4492,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4183,7 +4518,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for NotInitializing { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NotInitializing()"; const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8]; #[inline] @@ -4199,9 +4536,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `OutdatedState()` and selector `0x051c46ef`. - ```solidity - error OutdatedState(); - ```*/ +```solidity +error OutdatedState(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OutdatedState {} @@ -4219,11 +4556,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4243,7 +4582,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for OutdatedState { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OutdatedState()"; const SELECTOR: [u8; 4] = [5u8, 28u8, 70u8, 239u8]; #[inline] @@ -4259,9 +4600,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`. - ```solidity - error OwnableInvalidOwner(address owner); - ```*/ +```solidity +error OwnableInvalidOwner(address owner); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableInvalidOwner { @@ -4282,11 +4623,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4306,7 +4649,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for OwnableInvalidOwner { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableInvalidOwner(address)"; const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8]; #[inline] @@ -4326,9 +4671,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`. - ```solidity - error OwnableUnauthorizedAccount(address account); - ```*/ +```solidity +error OwnableUnauthorizedAccount(address account); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableUnauthorizedAccount { @@ -4349,23 +4694,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: OwnableUnauthorizedAccount) -> Self { (value.account,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for OwnableUnauthorizedAccount { + impl ::core::convert::From> + for OwnableUnauthorizedAccount { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { account: tuple.0 } } @@ -4373,7 +4722,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for OwnableUnauthorizedAccount { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)"; const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8]; #[inline] @@ -4393,9 +4744,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `ProverNotPermissioned()` and selector `0xa3a64780`. - ```solidity - error ProverNotPermissioned(); - ```*/ +```solidity +error ProverNotPermissioned(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ProverNotPermissioned {} @@ -4413,11 +4764,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4437,7 +4790,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for ProverNotPermissioned { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "ProverNotPermissioned()"; const SELECTOR: [u8; 4] = [163u8, 166u8, 71u8, 128u8]; #[inline] @@ -4453,9 +4808,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `UUPSUnauthorizedCallContext()` and selector `0xe07c8dba`. - ```solidity - error UUPSUnauthorizedCallContext(); - ```*/ +```solidity +error UUPSUnauthorizedCallContext(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnauthorizedCallContext {} @@ -4473,23 +4828,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnauthorizedCallContext) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnauthorizedCallContext { + impl ::core::convert::From> + for UUPSUnauthorizedCallContext { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -4497,7 +4856,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnauthorizedCallContext { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnauthorizedCallContext()"; const SELECTOR: [u8; 4] = [224u8, 124u8, 141u8, 186u8]; #[inline] @@ -4513,9 +4874,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `UUPSUnsupportedProxiableUUID(bytes32)` and selector `0xaa1d49a4`. - ```solidity - error UUPSUnsupportedProxiableUUID(bytes32 slot); - ```*/ +```solidity +error UUPSUnsupportedProxiableUUID(bytes32 slot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UUPSUnsupportedProxiableUUID { @@ -4536,23 +4897,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UUPSUnsupportedProxiableUUID) -> Self { (value.slot,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UUPSUnsupportedProxiableUUID { + impl ::core::convert::From> + for UUPSUnsupportedProxiableUUID { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { slot: tuple.0 } } @@ -4560,7 +4925,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for UUPSUnsupportedProxiableUUID { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UUPSUnsupportedProxiableUUID(bytes32)"; const SELECTOR: [u8; 4] = [170u8, 29u8, 73u8, 164u8]; #[inline] @@ -4580,9 +4947,9 @@ pub mod LightClientMock { } }; /**Custom error with signature `WrongStakeTableUsed()` and selector `0x51618089`. - ```solidity - error WrongStakeTableUsed(); - ```*/ +```solidity +error WrongStakeTableUsed(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct WrongStakeTableUsed {} @@ -4600,11 +4967,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -4624,7 +4993,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolError for WrongStakeTableUsed { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "WrongStakeTableUsed()"; const SELECTOR: [u8; 4] = [81u8, 97u8, 128u8, 137u8]; #[inline] @@ -4640,9 +5011,9 @@ pub mod LightClientMock { } }; /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`. - ```solidity - event Initialized(uint64 version); - ```*/ +```solidity +event Initialized(uint64 version); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4665,15 +5036,45 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for Initialized { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Initialized(uint64)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4688,20 +5089,22 @@ pub mod LightClientMock { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.version, - ), + as alloy_sol_types::SolType>::tokenize(&self.version), ) } #[inline] @@ -4716,7 +5119,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -4738,9 +5143,9 @@ pub mod LightClientMock { } }; /**Event with signature `NewState(uint64,uint64,uint256)` and selector `0xa04a773924505a418564363725f56832f5772e6b8d0dbd6efce724dfe803dae6`. - ```solidity - event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +event NewState(uint64 indexed viewNum, uint64 indexed blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4767,19 +5172,49 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for NewState { type DataTuple<'a> = (BN254::ScalarField,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, ); const SIGNATURE: &'static str = "NewState(uint64,uint64,uint256)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, - 37u8, 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, - 252u8, 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4798,19 +5233,23 @@ pub mod LightClientMock { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { - (::tokenize( - &self.blockCommRoot, - ),) + ( + ::tokenize( + &self.blockCommRoot, + ), + ) } #[inline] fn topics(&self) -> ::RustType { @@ -4828,7 +5267,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = as alloy_sol_types::EventTopic>::encode_topic(&self.viewNum); @@ -4856,9 +5297,9 @@ pub mod LightClientMock { } }; /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. - ```solidity - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - ```*/ +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4883,19 +5324,49 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for OwnershipTransferred { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, - 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, - 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -4913,11 +5384,13 @@ pub mod LightClientMock { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -4941,7 +5414,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.previousOwner, ); @@ -4969,9 +5444,9 @@ pub mod LightClientMock { } }; /**Event with signature `PermissionedProverNotRequired()` and selector `0x9a5f57de856dd668c54dd95e5c55df93432171cbca49a8776d5620ea59c02450`. - ```solidity - event PermissionedProverNotRequired(); - ```*/ +```solidity +event PermissionedProverNotRequired(); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -4991,15 +5466,45 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverNotRequired { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverNotRequired()"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -5014,11 +5519,13 @@ pub mod LightClientMock { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -5038,7 +5545,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -5054,15 +5563,17 @@ pub mod LightClientMock { #[automatically_derived] impl From<&PermissionedProverNotRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverNotRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverNotRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `PermissionedProverRequired(address)` and selector `0x8017bb887fdf8fca4314a9d40f6e73b3b81002d67e5cfa85d88173af6aa46072`. - ```solidity - event PermissionedProverRequired(address permissionedProver); - ```*/ +```solidity +event PermissionedProverRequired(address permissionedProver); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -5085,15 +5596,45 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for PermissionedProverRequired { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "PermissionedProverRequired(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, - 212u8, 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, - 133u8, 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -5101,20 +5642,20 @@ pub mod LightClientMock { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - permissionedProver: data.0, - } + Self { permissionedProver: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -5138,7 +5679,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -5154,15 +5697,17 @@ pub mod LightClientMock { #[automatically_derived] impl From<&PermissionedProverRequired> for alloy_sol_types::private::LogData { #[inline] - fn from(this: &PermissionedProverRequired) -> alloy_sol_types::private::LogData { + fn from( + this: &PermissionedProverRequired, + ) -> alloy_sol_types::private::LogData { alloy_sol_types::SolEvent::encode_log_data(this) } } }; /**Event with signature `Upgrade(address)` and selector `0xf78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d`. - ```solidity - event Upgrade(address implementation); - ```*/ +```solidity +event Upgrade(address implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -5185,15 +5730,45 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgrade { type DataTuple<'a> = (alloy::sol_types::sol_data::Address,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Upgrade(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, - 237u8, 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -5201,20 +5776,20 @@ pub mod LightClientMock { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: data.0, - } + Self { implementation: data.0 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -5238,7 +5813,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -5260,9 +5837,9 @@ pub mod LightClientMock { } }; /**Event with signature `Upgraded(address)` and selector `0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b`. - ```solidity - event Upgraded(address indexed implementation); - ```*/ +```solidity +event Upgraded(address indexed implementation); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -5285,18 +5862,48 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolEvent for Upgraded { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "Upgraded(address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, - 179u8, 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, - 192u8, 34u8, 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -5304,20 +5911,20 @@ pub mod LightClientMock { topics: ::RustType, data: as alloy_sol_types::SolType>::RustType, ) -> Self { - Self { - implementation: topics.1, - } + Self { implementation: topics.1 } } #[inline] fn check_signature( topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -5337,7 +5944,9 @@ pub mod LightClientMock { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.implementation, ); @@ -5362,17 +5971,16 @@ pub mod LightClientMock { } }; /**Constructor`. - ```solidity - constructor(LightClient.LightClientState genesis, LightClient.StakeTableState genesisStakeTableState, uint32 maxHistorySeconds); - ```*/ +```solidity +constructor(LightClient.LightClientState genesis, LightClient.StakeTableState genesisStakeTableState, uint32 maxHistorySeconds); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct constructorCall { #[allow(missing_docs)] pub genesis: ::RustType, #[allow(missing_docs)] - pub genesisStakeTableState: - ::RustType, + pub genesisStakeTableState: ::RustType, #[allow(missing_docs)] pub maxHistorySeconds: u32, } @@ -5393,11 +6001,13 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5430,7 +6040,9 @@ pub mod LightClientMock { LightClient::StakeTableState, alloy::sol_types::sol_data::Uint<32>, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -5446,17 +6058,17 @@ pub mod LightClientMock { ::tokenize( &self.genesisStakeTableState, ), - as alloy_sol_types::SolType>::tokenize( - &self.maxHistorySeconds, - ), + as alloy_sol_types::SolType>::tokenize(&self.maxHistorySeconds), ) } } }; /**Function with signature `UPGRADE_INTERFACE_VERSION()` and selector `0xad3cb1cc`. - ```solidity - function UPGRADE_INTERFACE_VERSION() external view returns (string memory); - ```*/ +```solidity +function UPGRADE_INTERFACE_VERSION() external view returns (string memory); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UPGRADE_INTERFACE_VERSIONCall {} @@ -5482,23 +6094,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONCall { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5511,23 +6127,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: UPGRADE_INTERFACE_VERSIONReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for UPGRADE_INTERFACE_VERSIONReturn { + impl ::core::convert::From> + for UPGRADE_INTERFACE_VERSIONReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5536,10 +6156,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for UPGRADE_INTERFACE_VERSIONCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = UPGRADE_INTERFACE_VERSIONReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UPGRADE_INTERFACE_VERSION()"; const SELECTOR: [u8; 4] = [173u8, 60u8, 177u8, 204u8]; #[inline] @@ -5557,17 +6181,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `currentBlockNumber()` and selector `0x378ec23b`. - ```solidity - function currentBlockNumber() external view returns (uint256); - ```*/ +```solidity +function currentBlockNumber() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct currentBlockNumberCall {} @@ -5593,23 +6217,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberCall { + impl ::core::convert::From> + for currentBlockNumberCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5619,26 +6247,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: currentBlockNumberReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for currentBlockNumberReturn { + impl ::core::convert::From> + for currentBlockNumberReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -5647,10 +6281,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for currentBlockNumberCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = currentBlockNumberReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "currentBlockNumber()"; const SELECTOR: [u8; 4] = [55u8, 142u8, 194u8, 59u8]; #[inline] @@ -5668,17 +6306,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `disablePermissionedProverMode()` and selector `0x69cc6a04`. - ```solidity - function disablePermissionedProverMode() external; - ```*/ +```solidity +function disablePermissionedProverMode() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct disablePermissionedProverModeCall {} @@ -5701,23 +6339,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeCall { + impl ::core::convert::From> + for disablePermissionedProverModeCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5730,23 +6372,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: disablePermissionedProverModeReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for disablePermissionedProverModeReturn { + impl ::core::convert::From> + for disablePermissionedProverModeReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5755,10 +6401,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for disablePermissionedProverModeCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = disablePermissionedProverModeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "disablePermissionedProverMode()"; const SELECTOR: [u8; 4] = [105u8, 204u8, 106u8, 4u8]; #[inline] @@ -5776,17 +6426,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `finalizedState()` and selector `0x9fdb54a7`. - ```solidity - function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function finalizedState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct finalizedStateCall {} @@ -5816,11 +6466,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -5853,23 +6505,27 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: finalizedStateReturn) -> Self { (value.viewNum, value.blockHeight, value.blockCommRoot) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for finalizedStateReturn { + impl ::core::convert::From> + for finalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { viewNum: tuple.0, @@ -5882,14 +6538,18 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for finalizedStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = finalizedStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "finalizedState()"; const SELECTOR: [u8; 4] = [159u8, 219u8, 84u8, 167u8]; #[inline] @@ -5907,17 +6567,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisStakeTableState()` and selector `0x426d3194`. - ```solidity - function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); - ```*/ +```solidity +function genesisStakeTableState() external view returns (uint256 threshold, BN254.ScalarField blsKeyComm, BN254.ScalarField schnorrKeyComm, BN254.ScalarField amountComm); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStakeTableStateCall {} @@ -5949,23 +6609,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateCall { + impl ::core::convert::From> + for genesisStakeTableStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -5988,16 +6652,19 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: genesisStakeTableStateReturn) -> Self { ( value.threshold, @@ -6009,7 +6676,8 @@ pub mod LightClientMock { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for genesisStakeTableStateReturn { + impl ::core::convert::From> + for genesisStakeTableStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { threshold: tuple.0, @@ -6023,7 +6691,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStakeTableStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStakeTableStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<256>, @@ -6031,7 +6701,9 @@ pub mod LightClientMock { BN254::ScalarField, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisStakeTableState()"; const SELECTOR: [u8; 4] = [66u8, 109u8, 49u8, 148u8]; #[inline] @@ -6049,17 +6721,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `genesisState()` and selector `0xd24d933d`. - ```solidity - function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); - ```*/ +```solidity +function genesisState() external view returns (uint64 viewNum, uint64 blockHeight, BN254.ScalarField blockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct genesisStateCall {} @@ -6089,11 +6761,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6126,11 +6800,13 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6155,14 +6831,18 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for genesisStateCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = genesisStateReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "genesisState()"; const SELECTOR: [u8; 4] = [210u8, 77u8, 147u8, 61u8]; #[inline] @@ -6180,17 +6860,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getHotShotCommitment(uint256)` and selector `0x8584d23f`. - ```solidity - function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); - ```*/ +```solidity +function getHotShotCommitment(uint256 hotShotBlockHeight) external view returns (BN254.ScalarField hotShotBlockCommRoot, uint64 hotshotBlockHeight); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getHotShotCommitmentCall { @@ -6218,26 +6898,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentCall) -> Self { (value.hotShotBlockHeight,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentCall { + impl ::core::convert::From> + for getHotShotCommitmentCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockHeight: tuple.0, @@ -6247,8 +6933,10 @@ pub mod LightClientMock { } { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); + type UnderlyingSolTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( ::RustType, @@ -6256,23 +6944,27 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getHotShotCommitmentReturn) -> Self { (value.hotShotBlockCommRoot, value.hotshotBlockHeight) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getHotShotCommitmentReturn { + impl ::core::convert::From> + for getHotShotCommitmentReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { hotShotBlockCommRoot: tuple.0, @@ -6284,10 +6976,17 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for getHotShotCommitmentCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getHotShotCommitmentReturn; - type ReturnTuple<'a> = (BN254::ScalarField, alloy::sol_types::sol_data::Uint<64>); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnTuple<'a> = ( + BN254::ScalarField, + alloy::sol_types::sol_data::Uint<64>, + ); + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getHotShotCommitment(uint256)"; const SELECTOR: [u8; 4] = [133u8, 132u8, 210u8, 63u8]; #[inline] @@ -6299,9 +6998,9 @@ pub mod LightClientMock { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.hotShotBlockHeight, - ), + as alloy_sol_types::SolType>::tokenize(&self.hotShotBlockHeight), ) } #[inline] @@ -6309,17 +7008,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getStateHistoryCount()` and selector `0xf9e50d19`. - ```solidity - function getStateHistoryCount() external view returns (uint256); - ```*/ +```solidity +function getStateHistoryCount() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getStateHistoryCountCall {} @@ -6345,23 +7044,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountCall { + impl ::core::convert::From> + for getStateHistoryCountCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6371,26 +7074,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: getStateHistoryCountReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for getStateHistoryCountReturn { + impl ::core::convert::From> + for getStateHistoryCountReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6399,10 +7108,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for getStateHistoryCountCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getStateHistoryCountReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getStateHistoryCount()"; const SELECTOR: [u8; 4] = [249u8, 229u8, 13u8, 25u8]; #[inline] @@ -6420,17 +7133,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `getVersion()` and selector `0x0d8e6e2c`. - ```solidity - function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); - ```*/ +```solidity +function getVersion() external pure returns (uint8 majorVersion, uint8 minorVersion, uint8 patchVersion); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct getVersionCall {} @@ -6460,11 +7173,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6493,11 +7208,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (u8, u8, u8); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6522,14 +7239,18 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for getVersionCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = getVersionReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, alloy::sol_types::sol_data::Uint<8>, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "getVersion()"; const SELECTOR: [u8; 4] = [13u8, 142u8, 110u8, 44u8]; #[inline] @@ -6547,25 +7268,24 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)` and selector `0x9baa3cc9`. - ```solidity - function initialize(LightClient.LightClientState memory _genesis, LightClient.StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; - ```*/ +```solidity +function initialize(LightClient.LightClientState memory _genesis, LightClient.StakeTableState memory _genesisStakeTableState, uint32 _stateHistoryRetentionPeriod, address owner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializeCall { #[allow(missing_docs)] pub _genesis: ::RustType, #[allow(missing_docs)] - pub _genesisStakeTableState: - ::RustType, + pub _genesisStakeTableState: ::RustType, #[allow(missing_docs)] pub _stateHistoryRetentionPeriod: u32, #[allow(missing_docs)] @@ -6600,11 +7320,13 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6639,11 +7361,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -6669,10 +7393,14 @@ pub mod LightClientMock { alloy::sol_types::sol_data::Uint<32>, alloy::sol_types::sol_data::Address, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initialize((uint64,uint64,uint256),(uint256,uint256,uint256,uint256),uint32,address)"; const SELECTOR: [u8; 4] = [155u8, 170u8, 60u8, 201u8]; #[inline] @@ -6690,7 +7418,9 @@ pub mod LightClientMock { ::tokenize( &self._genesisStakeTableState, ), - as alloy_sol_types::SolType>::tokenize( + as alloy_sol_types::SolType>::tokenize( &self._stateHistoryRetentionPeriod, ), ::tokenize( @@ -6703,17 +7433,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `isPermissionedProverEnabled()` and selector `0x826e41fc`. - ```solidity - function isPermissionedProverEnabled() external view returns (bool); - ```*/ +```solidity +function isPermissionedProverEnabled() external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct isPermissionedProverEnabledCall {} @@ -6739,23 +7469,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledCall { + impl ::core::convert::From> + for isPermissionedProverEnabledCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -6768,23 +7502,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: isPermissionedProverEnabledReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for isPermissionedProverEnabledReturn { + impl ::core::convert::From> + for isPermissionedProverEnabledReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6793,10 +7531,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for isPermissionedProverEnabledCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = isPermissionedProverEnabledReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "isPermissionedProverEnabled()"; const SELECTOR: [u8; 4] = [130u8, 110u8, 65u8, 252u8]; #[inline] @@ -6814,17 +7556,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `lagOverEscapeHatchThreshold(uint256,uint256)` and selector `0xe0303301`. - ```solidity - function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 threshold) external view returns (bool); - ```*/ +```solidity +function lagOverEscapeHatchThreshold(uint256 blockNumber, uint256 threshold) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct lagOverEscapeHatchThresholdCall { @@ -6861,23 +7603,27 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdCall) -> Self { (value.blockNumber, value.threshold) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdCall { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { blockNumber: tuple.0, @@ -6893,23 +7639,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: lagOverEscapeHatchThresholdReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for lagOverEscapeHatchThresholdReturn { + impl ::core::convert::From> + for lagOverEscapeHatchThresholdReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -6921,10 +7671,14 @@ pub mod LightClientMock { alloy::sol_types::sol_data::Uint<256>, alloy::sol_types::sol_data::Uint<256>, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = lagOverEscapeHatchThresholdReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "lagOverEscapeHatchThreshold(uint256,uint256)"; const SELECTOR: [u8; 4] = [224u8, 48u8, 51u8, 1u8]; #[inline] @@ -6936,12 +7690,12 @@ pub mod LightClientMock { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.blockNumber, - ), - as alloy_sol_types::SolType>::tokenize( - &self.threshold, - ), + as alloy_sol_types::SolType>::tokenize(&self.blockNumber), + as alloy_sol_types::SolType>::tokenize(&self.threshold), ) } #[inline] @@ -6949,17 +7703,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x2063d4f7`. - ```solidity - function newFinalizedState(LightClient.LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; - ```*/ +```solidity +function newFinalizedState(LightClient.LightClientState memory newState, IPlonkVerifier.PlonkProof memory proof) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct newFinalizedStateCall { @@ -6982,8 +7736,10 @@ pub mod LightClientMock { use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (LightClient::LightClientState, IPlonkVerifier::PlonkProof); + type UnderlyingSolTuple<'a> = ( + LightClient::LightClientState, + IPlonkVerifier::PlonkProof, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( ::RustType, @@ -6991,23 +7747,27 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateCall) -> Self { (value.newState, value.proof) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateCall { + impl ::core::convert::From> + for newFinalizedStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newState: tuple.0, @@ -7023,23 +7783,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: newFinalizedStateReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for newFinalizedStateReturn { + impl ::core::convert::From> + for newFinalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7047,11 +7811,18 @@ pub mod LightClientMock { } #[automatically_derived] impl alloy_sol_types::SolCall for newFinalizedStateCall { - type Parameters<'a> = (LightClient::LightClientState, IPlonkVerifier::PlonkProof); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - type Return = newFinalizedStateReturn; + type Parameters<'a> = ( + LightClient::LightClientState, + IPlonkVerifier::PlonkProof, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Return = newFinalizedStateReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "newFinalizedState((uint64,uint64,uint256),((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [32u8, 99u8, 212u8, 247u8]; #[inline] @@ -7066,7 +7837,9 @@ pub mod LightClientMock { ::tokenize( &self.newState, ), - ::tokenize(&self.proof), + ::tokenize( + &self.proof, + ), ) } #[inline] @@ -7074,17 +7847,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `owner()` and selector `0x8da5cb5b`. - ```solidity - function owner() external view returns (address); - ```*/ +```solidity +function owner() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ownerCall {} @@ -7110,11 +7883,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7139,11 +7914,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7164,10 +7941,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for ownerCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = ownerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "owner()"; const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; #[inline] @@ -7185,17 +7966,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `permissionedProver()` and selector `0x313df7b1`. - ```solidity - function permissionedProver() external view returns (address); - ```*/ +```solidity +function permissionedProver() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct permissionedProverCall {} @@ -7221,23 +8002,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverCall { + impl ::core::convert::From> + for permissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7250,23 +8035,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: permissionedProverReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for permissionedProverReturn { + impl ::core::convert::From> + for permissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -7275,10 +8064,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for permissionedProverCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = permissionedProverReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "permissionedProver()"; const SELECTOR: [u8; 4] = [49u8, 61u8, 247u8, 177u8]; #[inline] @@ -7296,17 +8089,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `proxiableUUID()` and selector `0x52d1902d`. - ```solidity - function proxiableUUID() external view returns (bytes32); - ```*/ +```solidity +function proxiableUUID() external view returns (bytes32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct proxiableUUIDCall {} @@ -7332,11 +8125,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7361,11 +8156,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7386,10 +8183,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for proxiableUUIDCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = proxiableUUIDReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "proxiableUUID()"; const SELECTOR: [u8; 4] = [82u8, 209u8, 144u8, 45u8]; #[inline] @@ -7407,17 +8208,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `renounceOwnership()` and selector `0x715018a6`. - ```solidity - function renounceOwnership() external; - ```*/ +```solidity +function renounceOwnership() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct renounceOwnershipCall {} @@ -7440,23 +8241,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipCall { + impl ::core::convert::From> + for renounceOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7469,23 +8274,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipReturn { + impl ::core::convert::From> + for renounceOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7494,10 +8303,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for renounceOwnershipCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = renounceOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "renounceOwnership()"; const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; #[inline] @@ -7515,17 +8328,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setFinalizedState((uint64,uint64,uint256))` and selector `0xb5adea3c`. - ```solidity - function setFinalizedState(LightClient.LightClientState memory state) external; - ```*/ +```solidity +function setFinalizedState(LightClient.LightClientState memory state) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setFinalizedStateCall { @@ -7548,27 +8361,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (LightClient::LightClientState,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = - (::RustType,); + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setFinalizedStateCall) -> Self { (value.state,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setFinalizedStateCall { + impl ::core::convert::From> + for setFinalizedStateCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { state: tuple.0 } } @@ -7581,23 +8399,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setFinalizedStateReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setFinalizedStateReturn { + impl ::core::convert::From> + for setFinalizedStateReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7606,10 +8428,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for setFinalizedStateCall { type Parameters<'a> = (LightClient::LightClientState,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setFinalizedStateReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setFinalizedState((uint64,uint64,uint256))"; const SELECTOR: [u8; 4] = [181u8, 173u8, 234u8, 60u8]; #[inline] @@ -7631,17 +8457,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setHotShotDownSince(uint256)` and selector `0x2d52aad6`. - ```solidity - function setHotShotDownSince(uint256 l1Height) external; - ```*/ +```solidity +function setHotShotDownSince(uint256 l1Height) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setHotShotDownSinceCall { @@ -7664,26 +8490,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setHotShotDownSinceCall) -> Self { (value.l1Height,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setHotShotDownSinceCall { + impl ::core::convert::From> + for setHotShotDownSinceCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { l1Height: tuple.0 } } @@ -7696,23 +8528,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setHotShotDownSinceReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setHotShotDownSinceReturn { + impl ::core::convert::From> + for setHotShotDownSinceReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7721,10 +8557,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for setHotShotDownSinceCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setHotShotDownSinceReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setHotShotDownSince(uint256)"; const SELECTOR: [u8; 4] = [45u8, 82u8, 170u8, 214u8]; #[inline] @@ -7736,9 +8576,9 @@ pub mod LightClientMock { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.l1Height, - ), + as alloy_sol_types::SolType>::tokenize(&self.l1Height), ) } #[inline] @@ -7746,17 +8586,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setHotShotUp()` and selector `0xc8e5e498`. - ```solidity - function setHotShotUp() external; - ```*/ +```solidity +function setHotShotUp() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setHotShotUpCall {} @@ -7779,11 +8619,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7808,11 +8650,13 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -7833,10 +8677,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for setHotShotUpCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setHotShotUpReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setHotShotUp()"; const SELECTOR: [u8; 4] = [200u8, 229u8, 228u8, 152u8]; #[inline] @@ -7854,17 +8702,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setPermissionedProver(address)` and selector `0x013fa5fc`. - ```solidity - function setPermissionedProver(address prover) external; - ```*/ +```solidity +function setPermissionedProver(address prover) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setPermissionedProverCall { @@ -7890,23 +8738,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverCall) -> Self { (value.prover,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverCall { + impl ::core::convert::From> + for setPermissionedProverCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { prover: tuple.0 } } @@ -7919,23 +8771,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setPermissionedProverReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setPermissionedProverReturn { + impl ::core::convert::From> + for setPermissionedProverReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -7944,10 +8800,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for setPermissionedProverCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setPermissionedProverReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setPermissionedProver(address)"; const SELECTOR: [u8; 4] = [1u8, 63u8, 165u8, 252u8]; #[inline] @@ -7969,17 +8829,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setStateHistory((uint64,uint64,uint64,uint256)[])` and selector `0xf5676160`. - ```solidity - function setStateHistory(LightClient.StateHistoryCommitment[] memory _stateHistoryCommitments) external; - ```*/ +```solidity +function setStateHistory(LightClient.StateHistoryCommitment[] memory _stateHistoryCommitments) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setStateHistoryCall { @@ -8002,8 +8862,9 @@ pub mod LightClientMock { use alloy::sol_types as alloy_sol_types; { #[doc(hidden)] - type UnderlyingSolTuple<'a> = - (alloy::sol_types::sol_data::Array,); + type UnderlyingSolTuple<'a> = ( + alloy::sol_types::sol_data::Array, + ); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( alloy::sol_types::private::Vec< @@ -8012,11 +8873,13 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -8043,23 +8906,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setStateHistoryReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setStateHistoryReturn { + impl ::core::convert::From> + for setStateHistoryReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8067,12 +8934,17 @@ pub mod LightClientMock { } #[automatically_derived] impl alloy_sol_types::SolCall for setStateHistoryCall { - type Parameters<'a> = - (alloy::sol_types::sol_data::Array,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Parameters<'a> = ( + alloy::sol_types::sol_data::Array, + ); + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setStateHistoryReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setStateHistory((uint64,uint64,uint64,uint256)[])"; const SELECTOR: [u8; 4] = [245u8, 103u8, 97u8, 96u8]; #[inline] @@ -8083,28 +8955,30 @@ pub mod LightClientMock { } #[inline] fn tokenize(&self) -> Self::Token<'_> { - ( as alloy_sol_types::SolType>::tokenize( - &self._stateHistoryCommitments, - ),) + ( + as alloy_sol_types::SolType>::tokenize( + &self._stateHistoryCommitments, + ), + ) } #[inline] fn abi_decode_returns( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `setstateHistoryRetentionPeriod(uint32)` and selector `0x96c1ca61`. - ```solidity - function setstateHistoryRetentionPeriod(uint32 historySeconds) external; - ```*/ +```solidity +function setstateHistoryRetentionPeriod(uint32 historySeconds) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct setstateHistoryRetentionPeriodCall { @@ -8130,27 +9004,29 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodCall) -> Self { (value.historySeconds,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - historySeconds: tuple.0, - } + Self { historySeconds: tuple.0 } } } } @@ -8161,23 +9037,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: setstateHistoryRetentionPeriodReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for setstateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for setstateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8186,10 +9066,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for setstateHistoryRetentionPeriodCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = setstateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "setstateHistoryRetentionPeriod(uint32)"; const SELECTOR: [u8; 4] = [150u8, 193u8, 202u8, 97u8]; #[inline] @@ -8201,9 +9085,9 @@ pub mod LightClientMock { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.historySeconds, - ), + as alloy_sol_types::SolType>::tokenize(&self.historySeconds), ) } #[inline] @@ -8211,17 +9095,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryCommitments(uint256)` and selector `0x02b592f3`. - ```solidity - function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); - ```*/ +```solidity +function stateHistoryCommitments(uint256) external view returns (uint64 l1BlockHeight, uint64 l1BlockTimestamp, uint64 hotShotBlockHeight, BN254.ScalarField hotShotBlockCommRoot); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryCommitmentsCall { @@ -8253,26 +9137,32 @@ pub mod LightClientMock { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsCall) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsCall { + impl ::core::convert::From> + for stateHistoryCommitmentsCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -8295,16 +9185,19 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryCommitmentsReturn) -> Self { ( value.l1BlockHeight, @@ -8316,7 +9209,8 @@ pub mod LightClientMock { } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryCommitmentsReturn { + impl ::core::convert::From> + for stateHistoryCommitmentsReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { l1BlockHeight: tuple.0, @@ -8330,7 +9224,9 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryCommitmentsCall { type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryCommitmentsReturn; type ReturnTuple<'a> = ( alloy::sol_types::sol_data::Uint<64>, @@ -8338,7 +9234,9 @@ pub mod LightClientMock { alloy::sol_types::sol_data::Uint<64>, BN254::ScalarField, ); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryCommitments(uint256)"; const SELECTOR: [u8; 4] = [2u8, 181u8, 146u8, 243u8]; #[inline] @@ -8350,9 +9248,9 @@ pub mod LightClientMock { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self._0, - ), + as alloy_sol_types::SolType>::tokenize(&self._0), ) } #[inline] @@ -8360,17 +9258,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryFirstIndex()` and selector `0x2f79889d`. - ```solidity - function stateHistoryFirstIndex() external view returns (uint64); - ```*/ +```solidity +function stateHistoryFirstIndex() external view returns (uint64); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryFirstIndexCall {} @@ -8396,23 +9294,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexCall { + impl ::core::convert::From> + for stateHistoryFirstIndexCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8425,23 +9327,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (u64,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryFirstIndexReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryFirstIndexReturn { + impl ::core::convert::From> + for stateHistoryFirstIndexReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -8450,10 +9356,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryFirstIndexCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryFirstIndexReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryFirstIndex()"; const SELECTOR: [u8; 4] = [47u8, 121u8, 136u8, 157u8]; #[inline] @@ -8471,17 +9381,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `stateHistoryRetentionPeriod()` and selector `0xc23b9e9e`. - ```solidity - function stateHistoryRetentionPeriod() external view returns (uint32); - ```*/ +```solidity +function stateHistoryRetentionPeriod() external view returns (uint32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct stateHistoryRetentionPeriodCall {} @@ -8507,23 +9417,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodCall { + impl ::core::convert::From> + for stateHistoryRetentionPeriodCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8536,23 +9450,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (u32,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: stateHistoryRetentionPeriodReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for stateHistoryRetentionPeriodReturn { + impl ::core::convert::From> + for stateHistoryRetentionPeriodReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -8561,10 +9479,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for stateHistoryRetentionPeriodCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = stateHistoryRetentionPeriodReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "stateHistoryRetentionPeriod()"; const SELECTOR: [u8; 4] = [194u8, 59u8, 158u8, 158u8]; #[inline] @@ -8582,17 +9504,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. - ```solidity - function transferOwnership(address newOwner) external; - ```*/ +```solidity +function transferOwnership(address newOwner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct transferOwnershipCall { @@ -8618,23 +9540,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipCall) -> Self { (value.newOwner,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipCall { + impl ::core::convert::From> + for transferOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newOwner: tuple.0 } } @@ -8647,23 +9573,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipReturn { + impl ::core::convert::From> + for transferOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8672,10 +9602,14 @@ pub mod LightClientMock { #[automatically_derived] impl alloy_sol_types::SolCall for transferOwnershipCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = transferOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "transferOwnership(address)"; const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; #[inline] @@ -8697,17 +9631,17 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `upgradeToAndCall(address,bytes)` and selector `0x4f1ef286`. - ```solidity - function upgradeToAndCall(address newImplementation, bytes memory data) external payable; - ```*/ +```solidity +function upgradeToAndCall(address newImplementation, bytes memory data) external payable; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct upgradeToAndCallCall { @@ -8741,23 +9675,27 @@ pub mod LightClientMock { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallCall) -> Self { (value.newImplementation, value.data) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallCall { + impl ::core::convert::From> + for upgradeToAndCallCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newImplementation: tuple.0, @@ -8773,23 +9711,27 @@ pub mod LightClientMock { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: upgradeToAndCallReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for upgradeToAndCallReturn { + impl ::core::convert::From> + for upgradeToAndCallReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -8801,10 +9743,14 @@ pub mod LightClientMock { alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Bytes, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = upgradeToAndCallReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "upgradeToAndCall(address,bytes)"; const SELECTOR: [u8; 4] = [79u8, 30u8, 242u8, 134u8]; #[inline] @@ -8829,10 +9775,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -8944,76 +9890,86 @@ pub mod LightClientMock { match self { Self::UPGRADE_INTERFACE_VERSION(_) => { ::SELECTOR - }, + } Self::currentBlockNumber(_) => { ::SELECTOR - }, + } Self::disablePermissionedProverMode(_) => { ::SELECTOR - }, + } Self::finalizedState(_) => { ::SELECTOR - }, + } Self::genesisStakeTableState(_) => { ::SELECTOR - }, - Self::genesisState(_) => ::SELECTOR, + } + Self::genesisState(_) => { + ::SELECTOR + } Self::getHotShotCommitment(_) => { ::SELECTOR - }, + } Self::getStateHistoryCount(_) => { ::SELECTOR - }, - Self::getVersion(_) => ::SELECTOR, - Self::initialize(_) => ::SELECTOR, + } + Self::getVersion(_) => { + ::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } Self::isPermissionedProverEnabled(_) => { ::SELECTOR - }, + } Self::lagOverEscapeHatchThreshold(_) => { ::SELECTOR - }, + } Self::newFinalizedState(_) => { ::SELECTOR - }, + } Self::owner(_) => ::SELECTOR, Self::permissionedProver(_) => { ::SELECTOR - }, - Self::proxiableUUID(_) => ::SELECTOR, + } + Self::proxiableUUID(_) => { + ::SELECTOR + } Self::renounceOwnership(_) => { ::SELECTOR - }, + } Self::setFinalizedState(_) => { ::SELECTOR - }, + } Self::setHotShotDownSince(_) => { ::SELECTOR - }, - Self::setHotShotUp(_) => ::SELECTOR, + } + Self::setHotShotUp(_) => { + ::SELECTOR + } Self::setPermissionedProver(_) => { ::SELECTOR - }, + } Self::setStateHistory(_) => { ::SELECTOR - }, + } Self::setstateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::stateHistoryCommitments(_) => { ::SELECTOR - }, + } Self::stateHistoryFirstIndex(_) => { ::SELECTOR - }, + } Self::stateHistoryRetentionPeriod(_) => { ::SELECTOR - }, + } Self::transferOwnership(_) => { ::SELECTOR - }, + } Self::upgradeToAndCall(_) => { ::SELECTOR - }, + } } } #[inline] @@ -9034,17 +9990,17 @@ pub mod LightClientMock { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn setPermissionedProver( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::setPermissionedProver) + data, + validate, + ) + .map(LightClientMockCalls::setPermissionedProver) } setPermissionedProver }, @@ -9054,9 +10010,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::stateHistoryCommitments) + data, + validate, + ) + .map(LightClientMockCalls::stateHistoryCommitments) } stateHistoryCommitments }, @@ -9065,7 +10022,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockCalls::getVersion) } getVersion @@ -9076,9 +10036,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::newFinalizedState) + data, + validate, + ) + .map(LightClientMockCalls::newFinalizedState) } newFinalizedState }, @@ -9088,9 +10049,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::setHotShotDownSince) + data, + validate, + ) + .map(LightClientMockCalls::setHotShotDownSince) } setHotShotDownSince }, @@ -9100,9 +10062,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::stateHistoryFirstIndex) + data, + validate, + ) + .map(LightClientMockCalls::stateHistoryFirstIndex) } stateHistoryFirstIndex }, @@ -9112,9 +10075,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::permissionedProver) + data, + validate, + ) + .map(LightClientMockCalls::permissionedProver) } permissionedProver }, @@ -9124,9 +10088,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::currentBlockNumber) + data, + validate, + ) + .map(LightClientMockCalls::currentBlockNumber) } currentBlockNumber }, @@ -9136,9 +10101,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::genesisStakeTableState) + data, + validate, + ) + .map(LightClientMockCalls::genesisStakeTableState) } genesisStakeTableState }, @@ -9148,9 +10114,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::upgradeToAndCall) + data, + validate, + ) + .map(LightClientMockCalls::upgradeToAndCall) } upgradeToAndCall }, @@ -9160,9 +10127,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::proxiableUUID) + data, + validate, + ) + .map(LightClientMockCalls::proxiableUUID) } proxiableUUID }, @@ -9185,9 +10153,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::renounceOwnership) + data, + validate, + ) + .map(LightClientMockCalls::renounceOwnership) } renounceOwnership }, @@ -9210,9 +10179,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::getHotShotCommitment) + data, + validate, + ) + .map(LightClientMockCalls::getHotShotCommitment) } getHotShotCommitment }, @@ -9221,7 +10191,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockCalls::owner) } owner @@ -9244,7 +10217,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockCalls::initialize) } initialize @@ -9255,9 +10231,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::finalizedState) + data, + validate, + ) + .map(LightClientMockCalls::finalizedState) } finalizedState }, @@ -9267,9 +10244,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::UPGRADE_INTERFACE_VERSION) + data, + validate, + ) + .map(LightClientMockCalls::UPGRADE_INTERFACE_VERSION) } UPGRADE_INTERFACE_VERSION }, @@ -9279,9 +10257,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::setFinalizedState) + data, + validate, + ) + .map(LightClientMockCalls::setFinalizedState) } setFinalizedState }, @@ -9304,9 +10283,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::setHotShotUp) + data, + validate, + ) + .map(LightClientMockCalls::setHotShotUp) } setHotShotUp }, @@ -9316,9 +10296,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::genesisState) + data, + validate, + ) + .map(LightClientMockCalls::genesisState) } genesisState }, @@ -9341,9 +10322,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::transferOwnership) + data, + validate, + ) + .map(LightClientMockCalls::transferOwnership) } transferOwnership }, @@ -9353,10 +10335,11 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::setStateHistory) - } + data, + validate, + ) + .map(LightClientMockCalls::setStateHistory) + } setStateHistory }, { @@ -9365,18 +10348,21 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockCalls::getStateHistoryCount) + data, + validate, + ) + .map(LightClientMockCalls::getStateHistoryCount) } getStateHistoryCount }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -9524,114 +10510,169 @@ pub mod LightClientMock { match self { Self::UPGRADE_INTERFACE_VERSION(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::currentBlockNumber(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::disablePermissionedProverMode(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::finalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::genesisStakeTableState(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::genesisState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::getHotShotCommitment(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getStateHistoryCount(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::getVersion(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::initialize(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::isPermissionedProverEnabled(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::lagOverEscapeHatchThreshold(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::newFinalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::owner(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::permissionedProver(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::proxiableUUID(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::renounceOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setFinalizedState(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setHotShotDownSince(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::setHotShotUp(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setPermissionedProver(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::setStateHistory(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::setstateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryCommitments(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryFirstIndex(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::stateHistoryRetentionPeriod(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::transferOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::upgradeToAndCall(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -9719,56 +10760,64 @@ pub mod LightClientMock { match self { Self::AddressEmptyCode(_) => { ::SELECTOR - }, + } Self::ERC1967InvalidImplementation(_) => { ::SELECTOR - }, + } Self::ERC1967NonPayable(_) => { ::SELECTOR - }, + } Self::FailedInnerCall(_) => { ::SELECTOR - }, + } Self::InsufficientSnapshotHistory(_) => { ::SELECTOR - }, - Self::InvalidAddress(_) => ::SELECTOR, - Self::InvalidArgs(_) => ::SELECTOR, + } + Self::InvalidAddress(_) => { + ::SELECTOR + } + Self::InvalidArgs(_) => { + ::SELECTOR + } Self::InvalidHotShotBlockForCommitmentCheck(_) => { ::SELECTOR - }, + } Self::InvalidInitialization(_) => { ::SELECTOR - }, + } Self::InvalidMaxStateHistory(_) => { ::SELECTOR - }, - Self::InvalidProof(_) => ::SELECTOR, + } + Self::InvalidProof(_) => { + ::SELECTOR + } Self::NoChangeRequired(_) => { ::SELECTOR - }, + } Self::NotInitializing(_) => { ::SELECTOR - }, - Self::OutdatedState(_) => ::SELECTOR, + } + Self::OutdatedState(_) => { + ::SELECTOR + } Self::OwnableInvalidOwner(_) => { ::SELECTOR - }, + } Self::OwnableUnauthorizedAccount(_) => { ::SELECTOR - }, + } Self::ProverNotPermissioned(_) => { ::SELECTOR - }, + } Self::UUPSUnauthorizedCallContext(_) => { ::SELECTOR - }, + } Self::UUPSUnsupportedProxiableUUID(_) => { ::SELECTOR - }, + } Self::WrongStakeTableUsed(_) => { ::SELECTOR - }, + } } } #[inline] @@ -9789,14 +10838,16 @@ pub mod LightClientMock { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn OutdatedState( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockErrors::OutdatedState) } OutdatedState @@ -9806,7 +10857,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockErrors::InvalidProof) } InvalidProof @@ -9817,9 +10871,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::OwnableUnauthorizedAccount) + data, + validate, + ) + .map(LightClientMockErrors::OwnableUnauthorizedAccount) } OwnableUnauthorizedAccount }, @@ -9829,9 +10884,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::FailedInnerCall) + data, + validate, + ) + .map(LightClientMockErrors::FailedInnerCall) } FailedInnerCall }, @@ -9841,9 +10897,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::OwnableInvalidOwner) + data, + validate, + ) + .map(LightClientMockErrors::OwnableInvalidOwner) } OwnableInvalidOwner }, @@ -9853,9 +10910,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::ERC1967InvalidImplementation) + data, + validate, + ) + .map(LightClientMockErrors::ERC1967InvalidImplementation) } ERC1967InvalidImplementation }, @@ -9865,9 +10923,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::WrongStakeTableUsed) + data, + validate, + ) + .map(LightClientMockErrors::WrongStakeTableUsed) } WrongStakeTableUsed }, @@ -9892,9 +10951,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::AddressEmptyCode) + data, + validate, + ) + .map(LightClientMockErrors::AddressEmptyCode) } AddressEmptyCode }, @@ -9903,7 +10963,10 @@ pub mod LightClientMock { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(LightClientMockErrors::InvalidArgs) } InvalidArgs @@ -9914,9 +10977,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::ProverNotPermissioned) + data, + validate, + ) + .map(LightClientMockErrors::ProverNotPermissioned) } ProverNotPermissioned }, @@ -9926,9 +10990,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::NoChangeRequired) + data, + validate, + ) + .map(LightClientMockErrors::NoChangeRequired) } NoChangeRequired }, @@ -9938,9 +11003,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::UUPSUnsupportedProxiableUUID) + data, + validate, + ) + .map(LightClientMockErrors::UUPSUnsupportedProxiableUUID) } UUPSUnsupportedProxiableUUID }, @@ -9950,9 +11016,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::InsufficientSnapshotHistory) + data, + validate, + ) + .map(LightClientMockErrors::InsufficientSnapshotHistory) } InsufficientSnapshotHistory }, @@ -9962,9 +11029,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::ERC1967NonPayable) + data, + validate, + ) + .map(LightClientMockErrors::ERC1967NonPayable) } ERC1967NonPayable }, @@ -9974,9 +11042,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::NotInitializing) + data, + validate, + ) + .map(LightClientMockErrors::NotInitializing) } NotInitializing }, @@ -9986,9 +11055,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::UUPSUnauthorizedCallContext) + data, + validate, + ) + .map(LightClientMockErrors::UUPSUnauthorizedCallContext) } UUPSUnauthorizedCallContext }, @@ -9998,9 +11068,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::InvalidAddress) + data, + validate, + ) + .map(LightClientMockErrors::InvalidAddress) } InvalidAddress }, @@ -10010,9 +11081,10 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::InvalidMaxStateHistory) + data, + validate, + ) + .map(LightClientMockErrors::InvalidMaxStateHistory) } InvalidMaxStateHistory }, @@ -10022,18 +11094,21 @@ pub mod LightClientMock { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(LightClientMockErrors::InvalidInitialization) + data, + validate, + ) + .map(LightClientMockErrors::InvalidInitialization) } InvalidInitialization }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -10289,39 +11364,242 @@ pub mod LightClientMock { /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 32usize]] = &[ [ - 128u8, 23u8, 187u8, 136u8, 127u8, 223u8, 143u8, 202u8, 67u8, 20u8, 169u8, 212u8, - 15u8, 110u8, 115u8, 179u8, 184u8, 16u8, 2u8, 214u8, 126u8, 92u8, 250u8, 133u8, - 216u8, 129u8, 115u8, 175u8, 106u8, 164u8, 96u8, 114u8, + 128u8, + 23u8, + 187u8, + 136u8, + 127u8, + 223u8, + 143u8, + 202u8, + 67u8, + 20u8, + 169u8, + 212u8, + 15u8, + 110u8, + 115u8, + 179u8, + 184u8, + 16u8, + 2u8, + 214u8, + 126u8, + 92u8, + 250u8, + 133u8, + 216u8, + 129u8, + 115u8, + 175u8, + 106u8, + 164u8, + 96u8, + 114u8, ], [ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8, - 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8, - 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, ], [ - 154u8, 95u8, 87u8, 222u8, 133u8, 109u8, 214u8, 104u8, 197u8, 77u8, 217u8, 94u8, - 92u8, 85u8, 223u8, 147u8, 67u8, 33u8, 113u8, 203u8, 202u8, 73u8, 168u8, 119u8, - 109u8, 86u8, 32u8, 234u8, 89u8, 192u8, 36u8, 80u8, + 154u8, + 95u8, + 87u8, + 222u8, + 133u8, + 109u8, + 214u8, + 104u8, + 197u8, + 77u8, + 217u8, + 94u8, + 92u8, + 85u8, + 223u8, + 147u8, + 67u8, + 33u8, + 113u8, + 203u8, + 202u8, + 73u8, + 168u8, + 119u8, + 109u8, + 86u8, + 32u8, + 234u8, + 89u8, + 192u8, + 36u8, + 80u8, ], [ - 160u8, 74u8, 119u8, 57u8, 36u8, 80u8, 90u8, 65u8, 133u8, 100u8, 54u8, 55u8, 37u8, - 245u8, 104u8, 50u8, 245u8, 119u8, 46u8, 107u8, 141u8, 13u8, 189u8, 110u8, 252u8, - 231u8, 36u8, 223u8, 232u8, 3u8, 218u8, 230u8, + 160u8, + 74u8, + 119u8, + 57u8, + 36u8, + 80u8, + 90u8, + 65u8, + 133u8, + 100u8, + 54u8, + 55u8, + 37u8, + 245u8, + 104u8, + 50u8, + 245u8, + 119u8, + 46u8, + 107u8, + 141u8, + 13u8, + 189u8, + 110u8, + 252u8, + 231u8, + 36u8, + 223u8, + 232u8, + 3u8, + 218u8, + 230u8, ], [ - 188u8, 124u8, 215u8, 90u8, 32u8, 238u8, 39u8, 253u8, 154u8, 222u8, 186u8, 179u8, - 32u8, 65u8, 247u8, 85u8, 33u8, 77u8, 188u8, 107u8, 255u8, 169u8, 12u8, 192u8, 34u8, - 91u8, 57u8, 218u8, 46u8, 92u8, 45u8, 59u8, + 188u8, + 124u8, + 215u8, + 90u8, + 32u8, + 238u8, + 39u8, + 253u8, + 154u8, + 222u8, + 186u8, + 179u8, + 32u8, + 65u8, + 247u8, + 85u8, + 33u8, + 77u8, + 188u8, + 107u8, + 255u8, + 169u8, + 12u8, + 192u8, + 34u8, + 91u8, + 57u8, + 218u8, + 46u8, + 92u8, + 45u8, + 59u8, ], [ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, ], [ - 247u8, 135u8, 33u8, 34u8, 110u8, 254u8, 154u8, 27u8, 182u8, 120u8, 24u8, 154u8, - 22u8, 209u8, 85u8, 73u8, 40u8, 185u8, 242u8, 25u8, 46u8, 44u8, 185u8, 62u8, 237u8, - 168u8, 59u8, 121u8, 250u8, 64u8, 0u8, 125u8, + 247u8, + 135u8, + 33u8, + 34u8, + 110u8, + 254u8, + 154u8, + 27u8, + 182u8, + 120u8, + 24u8, + 154u8, + 22u8, + 209u8, + 85u8, + 73u8, + 40u8, + 185u8, + 242u8, + 25u8, + 46u8, + 44u8, + 185u8, + 62u8, + 237u8, + 168u8, + 59u8, + 121u8, + 250u8, + 64u8, + 0u8, + 125u8, ], ]; } @@ -10337,49 +11615,77 @@ pub mod LightClientMock { match topics.first().copied() { Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::Initialized) - }, + topics, + data, + validate, + ) + .map(Self::Initialized) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::NewState) - }, - Some(::SIGNATURE_HASH) => { + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::OwnershipTransferred) - }, + topics, + data, + validate, + ) + .map(Self::OwnershipTransferred) + } Some( ::SIGNATURE_HASH, - ) => ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverNotRequired), - Some(::SIGNATURE_HASH) => { + ) => { + ::decode_raw_log( + topics, + data, + validate, + ) + .map(Self::PermissionedProverNotRequired) + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::PermissionedProverRequired) - }, + topics, + data, + validate, + ) + .map(Self::PermissionedProverRequired) + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgrade) - }, + } Some(::SIGNATURE_HASH) => { - ::decode_raw_log(topics, data, validate) + ::decode_raw_log( + topics, + data, + validate, + ) .map(Self::Upgraded) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -10389,49 +11695,57 @@ pub mod LightClientMock { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::NewState(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::NewState(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), - Self::Upgraded(inner) => alloy_sol_types::private::IntoLogData::to_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } + Self::Upgraded(inner) => { + alloy_sol_types::private::IntoLogData::to_log_data(inner) + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::NewState(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverNotRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::PermissionedProverRequired(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, - Self::Upgrade(inner) => alloy_sol_types::private::IntoLogData::into_log_data(inner), + } + Self::Upgrade(inner) => { + alloy_sol_types::private::IntoLogData::into_log_data(inner) + } Self::Upgraded(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`LightClientMock`](self) contract instance. - See the [wrapper's documentation](`LightClientMockInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientMockInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -10445,9 +11759,9 @@ pub mod LightClientMock { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -10458,20 +11772,20 @@ pub mod LightClientMock { genesis: ::RustType, genesisStakeTableState: ::RustType, maxHistorySeconds: u32, - ) -> impl ::core::future::Future>> - { - LightClientMockInstance::::deploy( - provider, - genesis, - genesisStakeTableState, - maxHistorySeconds, - ) + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { + LightClientMockInstance::< + T, + P, + N, + >::deploy(provider, genesis, genesisStakeTableState, maxHistorySeconds) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -10483,24 +11797,23 @@ pub mod LightClientMock { genesisStakeTableState: ::RustType, maxHistorySeconds: u32, ) -> alloy_contract::RawCallBuilder { - LightClientMockInstance::::deploy_builder( - provider, - genesis, - genesisStakeTableState, - maxHistorySeconds, - ) + LightClientMockInstance::< + T, + P, + N, + >::deploy_builder(provider, genesis, genesisStakeTableState, maxHistorySeconds) } /**A [`LightClientMock`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`LightClientMock`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`LightClientMock`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct LightClientMockInstance { address: alloy_sol_types::private::Address, @@ -10511,24 +11824,24 @@ pub mod LightClientMock { impl ::core::fmt::Debug for LightClientMockInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("LightClientMockInstance") - .field(&self.address) - .finish() + f.debug_tuple("LightClientMockInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientMockInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientMockInstance { /**Creates a new wrapper around an on-chain [`LightClientMock`](self) contract instance. - See the [wrapper's documentation](`LightClientMockInstance`) for more details.*/ +See the [wrapper's documentation](`LightClientMockInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -10537,9 +11850,9 @@ pub mod LightClientMock { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -10547,16 +11860,20 @@ pub mod LightClientMock { genesisStakeTableState: ::RustType, maxHistorySeconds: u32, ) -> alloy_contract::Result> { - let call_builder = - Self::deploy_builder(provider, genesis, genesisStakeTableState, maxHistorySeconds); + let call_builder = Self::deploy_builder( + provider, + genesis, + genesisStakeTableState, + maxHistorySeconds, + ); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder( provider: P, @@ -10568,14 +11885,16 @@ pub mod LightClientMock { provider, [ &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { - genesis, - genesisStakeTableState, - maxHistorySeconds, - })[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { + genesis, + genesisStakeTableState, + maxHistorySeconds, + }, + )[..], ] - .concat() - .into(), + .concat() + .into(), ) } /// Returns a reference to the address. @@ -10613,11 +11932,10 @@ pub mod LightClientMock { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientMockInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientMockInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -10643,8 +11961,16 @@ pub mod LightClientMock { ///Creates a new call builder for the [`disablePermissionedProverMode`] function. pub fn disablePermissionedProverMode( &self, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&disablePermissionedProverModeCall {}) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + disablePermissionedProverModeCall, + N, + > { + self.call_builder( + &disablePermissionedProverModeCall { + }, + ) } ///Creates a new call builder for the [`finalizedState`] function. pub fn finalizedState( @@ -10659,7 +11985,9 @@ pub mod LightClientMock { self.call_builder(&genesisStakeTableStateCall {}) } ///Creates a new call builder for the [`genesisState`] function. - pub fn genesisState(&self) -> alloy_contract::SolCallBuilder { + pub fn genesisState( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&genesisStateCall {}) } ///Creates a new call builder for the [`getHotShotCommitment`] function. @@ -10667,7 +11995,11 @@ pub mod LightClientMock { &self, hotShotBlockHeight: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&getHotShotCommitmentCall { hotShotBlockHeight }) + self.call_builder( + &getHotShotCommitmentCall { + hotShotBlockHeight, + }, + ) } ///Creates a new call builder for the [`getStateHistoryCount`] function. pub fn getStateHistoryCount( @@ -10676,7 +12008,9 @@ pub mod LightClientMock { self.call_builder(&getStateHistoryCountCall {}) } ///Creates a new call builder for the [`getVersion`] function. - pub fn getVersion(&self) -> alloy_contract::SolCallBuilder { + pub fn getVersion( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&getVersionCall {}) } ///Creates a new call builder for the [`initialize`] function. @@ -10687,12 +12021,14 @@ pub mod LightClientMock { _stateHistoryRetentionPeriod: u32, owner: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&initializeCall { - _genesis, - _genesisStakeTableState, - _stateHistoryRetentionPeriod, - owner, - }) + self.call_builder( + &initializeCall { + _genesis, + _genesisStakeTableState, + _stateHistoryRetentionPeriod, + owner, + }, + ) } ///Creates a new call builder for the [`isPermissionedProverEnabled`] function. pub fn isPermissionedProverEnabled( @@ -10706,10 +12042,12 @@ pub mod LightClientMock { blockNumber: alloy::sol_types::private::primitives::aliases::U256, threshold: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&lagOverEscapeHatchThresholdCall { - blockNumber, - threshold, - }) + self.call_builder( + &lagOverEscapeHatchThresholdCall { + blockNumber, + threshold, + }, + ) } ///Creates a new call builder for the [`newFinalizedState`] function. pub fn newFinalizedState( @@ -10717,7 +12055,12 @@ pub mod LightClientMock { newState: ::RustType, proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&newFinalizedStateCall { newState, proof }) + self.call_builder( + &newFinalizedStateCall { + newState, + proof, + }, + ) } ///Creates a new call builder for the [`owner`] function. pub fn owner(&self) -> alloy_contract::SolCallBuilder { @@ -10730,7 +12073,9 @@ pub mod LightClientMock { self.call_builder(&permissionedProverCall {}) } ///Creates a new call builder for the [`proxiableUUID`] function. - pub fn proxiableUUID(&self) -> alloy_contract::SolCallBuilder { + pub fn proxiableUUID( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&proxiableUUIDCall {}) } ///Creates a new call builder for the [`renounceOwnership`] function. @@ -10751,10 +12096,16 @@ pub mod LightClientMock { &self, l1Height: alloy::sol_types::private::primitives::aliases::U256, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setHotShotDownSinceCall { l1Height }) + self.call_builder( + &setHotShotDownSinceCall { + l1Height, + }, + ) } ///Creates a new call builder for the [`setHotShotUp`] function. - pub fn setHotShotUp(&self) -> alloy_contract::SolCallBuilder { + pub fn setHotShotUp( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&setHotShotUpCall {}) } ///Creates a new call builder for the [`setPermissionedProver`] function. @@ -10762,7 +12113,11 @@ pub mod LightClientMock { &self, prover: alloy::sol_types::private::Address, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setPermissionedProverCall { prover }) + self.call_builder( + &setPermissionedProverCall { + prover, + }, + ) } ///Creates a new call builder for the [`setStateHistory`] function. pub fn setStateHistory( @@ -10771,16 +12126,27 @@ pub mod LightClientMock { ::RustType, >, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setStateHistoryCall { - _stateHistoryCommitments, - }) + self.call_builder( + &setStateHistoryCall { + _stateHistoryCommitments, + }, + ) } ///Creates a new call builder for the [`setstateHistoryRetentionPeriod`] function. pub fn setstateHistoryRetentionPeriod( &self, historySeconds: u32, - ) -> alloy_contract::SolCallBuilder { - self.call_builder(&setstateHistoryRetentionPeriodCall { historySeconds }) + ) -> alloy_contract::SolCallBuilder< + T, + &P, + setstateHistoryRetentionPeriodCall, + N, + > { + self.call_builder( + &setstateHistoryRetentionPeriodCall { + historySeconds, + }, + ) } ///Creates a new call builder for the [`stateHistoryCommitments`] function. pub fn stateHistoryCommitments( @@ -10814,20 +12180,21 @@ pub mod LightClientMock { newImplementation: alloy::sol_types::private::Address, data: alloy::sol_types::private::Bytes, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&upgradeToAndCallCall { - newImplementation, - data, - }) + self.call_builder( + &upgradeToAndCallCall { + newImplementation, + data, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > LightClientMockInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > LightClientMockInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -10838,7 +12205,9 @@ pub mod LightClientMock { alloy_contract::Event::new_sol(&self.provider, &self.address) } ///Creates a new event filter for the [`Initialized`] event. - pub fn Initialized_filter(&self) -> alloy_contract::Event { + pub fn Initialized_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } ///Creates a new event filter for the [`NewState`] event. diff --git a/contract-bindings-alloy/src/permissionedstaketable.rs b/contract-bindings-alloy/src/permissionedstaketable.rs index 14d1f72146..389ee7f4c4 100644 --- a/contract-bindings-alloy/src/permissionedstaketable.rs +++ b/contract-bindings-alloy/src/permissionedstaketable.rs @@ -15,9 +15,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -25,24 +24,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -60,12 +64,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -84,11 +92,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -98,15 +108,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -127,16 +137,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G2Point { BaseField x0; BaseField x1; BaseField y0; BaseField y1; } - ```*/ +struct G2Point { BaseField x0; BaseField x1; BaseField y0; BaseField y1; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G2Point { @@ -168,11 +180,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -214,50 +228,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G2Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -271,9 +299,9 @@ pub mod BN254 { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -283,12 +311,15 @@ pub mod BN254 { #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.x0).0, - ::eip712_data_word(&self.x1).0, - ::eip712_data_word(&self.y0).0, + ::eip712_data_word(&self.x0) + .0, + ::eip712_data_word(&self.x1) + .0, + ::eip712_data_word(&self.y0) + .0, ::eip712_data_word(&self.y1).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -296,34 +327,63 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x0) - + ::topic_preimage_length(&rust.x1) - + ::topic_preimage_length(&rust.y0) - + ::topic_preimage_length(&rust.y1) + + ::topic_preimage_length( + &rust.x0, + ) + + ::topic_preimage_length( + &rust.x1, + ) + + ::topic_preimage_length( + &rust.y0, + ) + + ::topic_preimage_length( + &rust.y1, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x0, out); - ::encode_topic_preimage(&rust.x1, out); - ::encode_topic_preimage(&rust.y0, out); - ::encode_topic_preimage(&rust.y1, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x0, + out, + ); + ::encode_topic_preimage( + &rust.x1, + out, + ); + ::encode_topic_preimage( + &rust.y0, + out, + ); + ::encode_topic_preimage( + &rust.y1, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -337,15 +397,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -362,16 +422,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -413,11 +475,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -432,11 +493,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -464,12 +524,11 @@ library EdOnBN254 { clippy::empty_structs_with_brackets )] pub mod EdOnBN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct EdOnBN254Point { uint256 x; uint256 y; } - ```*/ +struct EdOnBN254Point { uint256 x; uint256 y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct EdOnBN254Point { @@ -498,11 +557,13 @@ pub mod EdOnBN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -516,10 +577,7 @@ pub mod EdOnBN254 { #[doc(hidden)] impl ::core::convert::From> for EdOnBN254Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -531,12 +589,12 @@ pub mod EdOnBN254 { #[inline] fn stv_to_tokens(&self) -> ::Token<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.x, - ), - as alloy_sol_types::SolType>::tokenize( - &self.y, - ), + as alloy_sol_types::SolType>::tokenize(&self.x), + as alloy_sol_types::SolType>::tokenize(&self.y), ) } #[inline] @@ -544,50 +602,64 @@ pub mod EdOnBN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for EdOnBN254Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -596,12 +668,14 @@ pub mod EdOnBN254 { const NAME: &'static str = "EdOnBN254Point"; #[inline] fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> { - alloy_sol_types::private::Cow::Borrowed("EdOnBN254Point(uint256 x,uint256 y)") + alloy_sol_types::private::Cow::Borrowed( + "EdOnBN254Point(uint256 x,uint256 y)", + ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -640,7 +714,9 @@ pub mod EdOnBN254 { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.x, out); @@ -649,17 +725,24 @@ pub mod EdOnBN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.y, out); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance. - See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/ +See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -673,15 +756,15 @@ pub mod EdOnBN254 { } /**A [`EdOnBN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`EdOnBN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`EdOnBN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct EdOnBN254Instance { address: alloy_sol_types::private::Address, @@ -692,24 +775,24 @@ pub mod EdOnBN254 { impl ::core::fmt::Debug for EdOnBN254Instance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("EdOnBN254Instance") - .field(&self.address) - .finish() + f.debug_tuple("EdOnBN254Instance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > EdOnBN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > EdOnBN254Instance { /**Creates a new wrapper around an on-chain [`EdOnBN254`](self) contract instance. - See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/ +See the [wrapper's documentation](`EdOnBN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -751,11 +834,10 @@ pub mod EdOnBN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > EdOnBN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > EdOnBN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -770,11 +852,10 @@ pub mod EdOnBN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > EdOnBN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > EdOnBN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -1361,9 +1442,8 @@ interface PermissionedStakeTable { clippy::empty_structs_with_brackets )] pub mod PermissionedStakeTable { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -1385,8 +1465,8 @@ pub mod PermissionedStakeTable { b"`\x80`@R4\x80\x15a\0\x0FW_\x80\xFD[P`\x046\x10a\0\x85W_5`\xE0\x1C\x80c\x8D\xA5\xCB[\x11a\0XW\x80c\x8D\xA5\xCB[\x14a\0\xDAW\x80c\x9B0\xA5\xE6\x14a\0\xF4W\x80c\xCB\xBA|x\x14a\x01\x07W\x80c\xF2\xFD\xE3\x8B\x14a\x01\x1AW_\x80\xFD[\x80c>\x9D\xF9\xB5\x14a\0\x89W\x80cqP\x18\xA6\x14a\0\xA5W\x80cu\xD7\x05\xE9\x14a\0\xAFW\x80c\x81)\xFC\x1C\x14a\0\xD2W[_\x80\xFD[a\0\x92`\x01T\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xADa\x01-V[\0[a\0\xC2a\0\xBD6`\x04a\x06NV[a\x01@V[`@Q\x90\x15\x15\x81R` \x01a\0\x9CV[a\0\xADa\x01fV[_T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\x9CV[a\0\x92a\x01\x026`\x04a\x06NV[a\x02nV[a\0\xADa\x01\x156`\x04a\x07eV[a\x02\xC8V[a\0\xADa\x01(6`\x04a\x08+V[a\x03\x1FV[a\x015a\x03aV[a\x01>_a\x03\x8DV[V[_`\x02_a\x01M\x84a\x02nV[\x81R` \x81\x01\x91\x90\x91R`@\x01_ T`\xFF\x16\x92\x91PPV[\x7F\xF0\xC5~\x16\x84\r\xF0@\xF1P\x88\xDC/\x81\xFE9\x1C9#\xBE\xC7>#\xA9f.\xFC\x9C\"\x9Cj\0\x80T`\x01`@\x1B\x81\x04`\xFF\x16\x15\x90g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16_\x81\x15\x80\x15a\x01\xABWP\x82[\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16`\x01\x14\x80\x15a\x01\xC7WP0;\x15[\x90P\x81\x15\x80\x15a\x01\xD5WP\x80\x15[\x15a\x01\xF3W`@Qc\xF9.\xE8\xA9`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[\x84Tg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\x01\x17\x85U\x83\x15a\x02\x1DW\x84T`\xFF`@\x1B\x19\x16`\x01`@\x1B\x17\x85U[C`\x01U\x83\x15a\x02gW\x84T`\xFF`@\x1B\x19\x16\x85U`@Q`\x01\x81R\x7F\xC7\xF5\x05\xB2\xF3q\xAE!u\xEEI\x13\xF4I\x9E\x1F&3\xA7\xB5\x93c!\xEE\xD1\xCD\xAE\xB6\x11Q\x81\xD2\x90` \x01`@Q\x80\x91\x03\x90\xA1[PPPPPV[_\x81_\x01Q\x82` \x01Q\x83`@\x01Q\x84``\x01Q`@Q` \x01a\x02\xAB\x94\x93\x92\x91\x90\x93\x84R` \x84\x01\x92\x90\x92R`@\x83\x01R``\x82\x01R`\x80\x01\x90V[`@Q` \x81\x83\x03\x03\x81R\x90`@R\x80Q\x90` \x01 \x90P\x91\x90PV[a\x02\xD0a\x03aV[a\x02\xD9\x82a\x03\xDCV[a\x02\xE2\x81a\x04\x98V[\x7FK\xB3\x1C\xD9\xAE\x87\xA3\xF8(\x95X\xC7\x9B\xE5#%\x06\xCE6\xDEBi\xC8\xBAE4\xA6\xFB\xE9\xE2\x96]\x82\x82`@Qa\x03\x13\x92\x91\x90a\x08QV[`@Q\x80\x91\x03\x90\xA1PPV[a\x03'a\x03aV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03UW`@Qc\x1EO\xBD\xF7`\xE0\x1B\x81R_`\x04\x82\x01R`$\x01[`@Q\x80\x91\x03\x90\xFD[a\x03^\x81a\x03\x8DV[PV[_T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x01>W`@Qc\x11\x8C\xDA\xA7`\xE0\x1B\x81R3`\x04\x82\x01R`$\x01a\x03LV[_\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[_[\x81Q\x81\x10\x15a\x04\x94W_a\x04\n\x83\x83\x81Q\x81\x10a\x03\xFDWa\x03\xFDa\t@V[` \x02` \x01\x01Qa\x02nV[_\x81\x81R`\x02` R`@\x90 T\x90\x91P`\xFF\x16a\x04wW\x82\x82\x81Q\x81\x10a\x044Wa\x044a\t@V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01Q`@\x80Qc4\xA7V\x1F`\xE0\x1B\x81R\x82Q`\x04\x82\x01R\x92\x82\x01Q`$\x84\x01R\x81\x01Q`D\x83\x01R``\x01Q`d\x82\x01R`\x84\x01a\x03LV[_\x90\x81R`\x02` R`@\x90 \x80T`\xFF\x19\x16\x90U`\x01\x01a\x03\xDEV[PPV[_[\x81Q\x81\x10\x15a\x04\x94W_a\x04\xC9\x83\x83\x81Q\x81\x10a\x04\xB9Wa\x04\xB9a\t@V[` \x02` \x01\x01Q_\x01Qa\x02nV[_\x81\x81R`\x02` R`@\x90 T\x90\x91P`\xFF\x16\x15a\x058W\x82\x82\x81Q\x81\x10a\x04\xF4Wa\x04\xF4a\t@V[` \x90\x81\x02\x91\x90\x91\x01\x81\x01QQ`@\x80Qc\x1B\x06\xE1A`\xE1\x1B\x81R\x82Q`\x04\x82\x01R\x92\x82\x01Q`$\x84\x01R\x81\x01Q`D\x83\x01R``\x01Q`d\x82\x01R`\x84\x01a\x03LV[_\x90\x81R`\x02` R`@\x90 \x80T`\xFF\x19\x16`\x01\x90\x81\x17\x90\x91U\x01a\x04\x9AV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Q``\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x05\x90Wa\x05\x90a\x05YV[`@R\x90V[`@\x80Q\x90\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x05\x90Wa\x05\x90a\x05YV[`@Q`\x1F\x82\x01`\x1F\x19\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x05\xE2Wa\x05\xE2a\x05YV[`@R\x91\x90PV[_`\x80\x82\x84\x03\x12\x15a\x05\xFAW_\x80\xFD[`@Q`\x80\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\x06\x1DWa\x06\x1Da\x05YV[\x80`@RP\x80\x91P\x825\x81R` \x83\x015` \x82\x01R`@\x83\x015`@\x82\x01R``\x83\x015``\x82\x01RP\x92\x91PPV[_`\x80\x82\x84\x03\x12\x15a\x06^W_\x80\xFD[a\x06h\x83\x83a\x05\xEAV[\x93\x92PPPV[_g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x15a\x06\x88Wa\x06\x88a\x05YV[P`\x05\x1B` \x01\x90V[_\x82`\x1F\x83\x01\x12a\x06\xA1W_\x80\xFD[\x815` a\x06\xB6a\x06\xB1\x83a\x06oV[a\x05\xB9V[\x82\x81R`\xE0\x92\x83\x02\x85\x01\x82\x01\x92\x82\x82\x01\x91\x90\x87\x85\x11\x15a\x06\xD4W_\x80\xFD[\x83\x87\x01[\x85\x81\x10\x15a\x07XW\x80\x89\x03\x82\x81\x12\x15a\x06\xEFW_\x80\xFD[a\x06\xF7a\x05mV[a\x07\x01\x8B\x84a\x05\xEAV[\x81R`@\x80`\x7F\x19\x84\x01\x12\x15a\x07\x15W_\x80\xFD[a\x07\x1Da\x05\x96V[`\x80\x85\x015\x81R`\xA0\x85\x015\x89\x82\x01R\x82\x89\x01R`\xC0\x84\x015\x92P\x82\x15\x15\x83\x14a\x07EW_\x80\xFD[\x81\x01\x91\x90\x91R\x84R\x92\x84\x01\x92\x81\x01a\x06\xD8V[P\x90\x97\x96PPPPPPPV[_\x80`@\x83\x85\x03\x12\x15a\x07vW_\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x07\x8DW_\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x07\xA0W_\x80\xFD[\x815` a\x07\xB0a\x06\xB1\x83a\x06oV[\x80\x83\x82R` \x82\x01\x91P` \x84`\x07\x1B\x87\x01\x01\x93P\x89\x84\x11\x15a\x07\xD1W_\x80\xFD[` \x86\x01\x95P[\x83\x86\x10\x15a\x07\xFCWa\x07\xEA\x8A\x87a\x05\xEAV[\x82R\x82\x82\x01\x91P`\x80\x86\x01\x95Pa\x07\xD8V[\x96PPPP` \x85\x015\x91P\x80\x82\x11\x15a\x08\x14W_\x80\xFD[Pa\x08!\x85\x82\x86\x01a\x06\x92V[\x91PP\x92P\x92\x90PV[_` \x82\x84\x03\x12\x15a\x08;W_\x80\xFD[\x815`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x06hW_\x80\xFD[`@\x80\x82R\x83Q\x82\x82\x01\x81\x90R_\x91\x90` \x90``\x85\x01\x90\x82\x88\x01\x85[\x82\x81\x10\x15a\x08\xB5Wa\x08\xA2\x84\x83Q\x80Q\x82R` \x81\x01Q` \x83\x01R`@\x81\x01Q`@\x83\x01R``\x81\x01Q``\x83\x01RPPV[`\x80\x93\x90\x93\x01\x92\x90\x84\x01\x90`\x01\x01a\x08nV[PPP\x84\x81\x03\x82\x86\x01R\x85Q\x80\x82R\x86\x83\x01\x91\x83\x01\x90_[\x81\x81\x10\x15a\t2W\x83Qa\t\x03\x84\x82Q\x80Q\x82R` \x81\x01Q` \x83\x01R`@\x81\x01Q`@\x83\x01R``\x81\x01Q``\x83\x01RPPV[\x80\x86\x01Q\x80Q`\x80\x86\x01R\x86\x01Q`\xA0\x85\x01R\x86\x01Q\x15\x15`\xC0\x84\x01R\x92\x84\x01\x92`\xE0\x90\x92\x01\x91`\x01\x01a\x08\xCDV[P\x90\x98\x97PPPPPPPPV[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD\xFE\xA1dsolcC\0\x08\x17\0\n", ); /**```solidity - struct NodeInfo { BN254.G2Point blsVK; EdOnBN254.EdOnBN254Point schnorrVK; bool isDA; } - ```*/ +struct NodeInfo { BN254.G2Point blsVK; EdOnBN254.EdOnBN254Point schnorrVK; bool isDA; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NodeInfo { @@ -1419,11 +1499,13 @@ pub mod PermissionedStakeTable { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1467,50 +1549,64 @@ pub mod PermissionedStakeTable { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for NodeInfo { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1524,19 +1620,26 @@ pub mod PermissionedStakeTable { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(2); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push( - ::eip712_root_type(), - ); - components.extend( - ::eip712_components(), - ); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] @@ -1578,7 +1681,9 @@ pub mod PermissionedStakeTable { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.blsVK, out, @@ -1593,17 +1698,24 @@ pub mod PermissionedStakeTable { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`. - ```solidity - error InvalidInitialization(); - ```*/ +```solidity +error InvalidInitialization(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct InvalidInitialization {} @@ -1621,11 +1733,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1645,7 +1759,9 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for InvalidInitialization { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidInitialization()"; const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8]; #[inline] @@ -1661,9 +1777,9 @@ pub mod PermissionedStakeTable { } }; /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`. - ```solidity - error NotInitializing(); - ```*/ +```solidity +error NotInitializing(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct NotInitializing {} @@ -1681,11 +1797,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1705,7 +1823,9 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for NotInitializing { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "NotInitializing()"; const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8]; #[inline] @@ -1721,9 +1841,9 @@ pub mod PermissionedStakeTable { } }; /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`. - ```solidity - error OwnableInvalidOwner(address owner); - ```*/ +```solidity +error OwnableInvalidOwner(address owner); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableInvalidOwner { @@ -1744,11 +1864,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1768,7 +1890,9 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for OwnableInvalidOwner { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableInvalidOwner(address)"; const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8]; #[inline] @@ -1788,9 +1912,9 @@ pub mod PermissionedStakeTable { } }; /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`. - ```solidity - error OwnableUnauthorizedAccount(address account); - ```*/ +```solidity +error OwnableUnauthorizedAccount(address account); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct OwnableUnauthorizedAccount { @@ -1811,23 +1935,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: OwnableUnauthorizedAccount) -> Self { (value.account,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for OwnableUnauthorizedAccount { + impl ::core::convert::From> + for OwnableUnauthorizedAccount { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { account: tuple.0 } } @@ -1835,7 +1963,9 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for OwnableUnauthorizedAccount { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)"; const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8]; #[inline] @@ -1855,9 +1985,9 @@ pub mod PermissionedStakeTable { } }; /**Custom error with signature `StakerAlreadyExists((uint256,uint256,uint256,uint256))` and selector `0x360dc282`. - ```solidity - error StakerAlreadyExists(BN254.G2Point); - ```*/ +```solidity +error StakerAlreadyExists(BN254.G2Point); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StakerAlreadyExists { @@ -1875,14 +2005,18 @@ pub mod PermissionedStakeTable { #[doc(hidden)] type UnderlyingSolTuple<'a> = (BN254::G2Point,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (::RustType,); + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1902,9 +2036,10 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for StakerAlreadyExists { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; - const SIGNATURE: &'static str = - "StakerAlreadyExists((uint256,uint256,uint256,uint256))"; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + const SIGNATURE: &'static str = "StakerAlreadyExists((uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [54u8, 13u8, 194u8, 130u8]; #[inline] fn new<'a>( @@ -1914,16 +2049,14 @@ pub mod PermissionedStakeTable { } #[inline] fn tokenize(&self) -> Self::Token<'_> { - (::tokenize( - &self._0, - ),) + (::tokenize(&self._0),) } } }; /**Custom error with signature `StakerNotFound((uint256,uint256,uint256,uint256))` and selector `0x34a7561f`. - ```solidity - error StakerNotFound(BN254.G2Point); - ```*/ +```solidity +error StakerNotFound(BN254.G2Point); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct StakerNotFound { @@ -1941,14 +2074,18 @@ pub mod PermissionedStakeTable { #[doc(hidden)] type UnderlyingSolTuple<'a> = (BN254::G2Point,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (::RustType,); + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1968,7 +2105,9 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolError for StakerNotFound { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "StakerNotFound((uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [52u8, 167u8, 86u8, 31u8]; #[inline] @@ -1979,16 +2118,14 @@ pub mod PermissionedStakeTable { } #[inline] fn tokenize(&self) -> Self::Token<'_> { - (::tokenize( - &self._0, - ),) + (::tokenize(&self._0),) } } }; /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`. - ```solidity - event Initialized(uint64 version); - ```*/ +```solidity +event Initialized(uint64 version); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -2011,15 +2148,45 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolEvent for Initialized { type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "Initialized(uint64)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -2034,20 +2201,22 @@ pub mod PermissionedStakeTable { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } #[inline] fn tokenize_body(&self) -> Self::DataToken<'_> { ( - as alloy_sol_types::SolType>::tokenize( - &self.version, - ), + as alloy_sol_types::SolType>::tokenize(&self.version), ) } #[inline] @@ -2062,7 +2231,9 @@ pub mod PermissionedStakeTable { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -2084,9 +2255,9 @@ pub mod PermissionedStakeTable { } }; /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`. - ```solidity - event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); - ```*/ +```solidity +event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -2111,19 +2282,49 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolEvent for OwnershipTransferred { type DataTuple<'a> = (); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = ( alloy_sol_types::sol_data::FixedBytes<32>, alloy::sol_types::sol_data::Address, alloy::sol_types::sol_data::Address, ); const SIGNATURE: &'static str = "OwnershipTransferred(address,address)"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, - 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, - 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -2141,11 +2342,13 @@ pub mod PermissionedStakeTable { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -2169,7 +2372,9 @@ pub mod PermissionedStakeTable { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); out[1usize] = ::encode_topic( &self.previousOwner, ); @@ -2197,9 +2402,9 @@ pub mod PermissionedStakeTable { } }; /**Event with signature `StakersUpdated((uint256,uint256,uint256,uint256)[],((uint256,uint256,uint256,uint256),(uint256,uint256),bool)[])` and selector `0x4bb31cd9ae87a3f8289558c79be5232506ce36de4269c8ba4534a6fbe9e2965d`. - ```solidity - event StakersUpdated(BN254.G2Point[] removed, NodeInfo[] added); - ```*/ +```solidity +event StakersUpdated(BN254.G2Point[] removed, NodeInfo[] added); +```*/ #[allow( non_camel_case_types, non_snake_case, @@ -2209,11 +2414,13 @@ pub mod PermissionedStakeTable { #[derive(Clone)] pub struct StakersUpdated { #[allow(missing_docs)] - pub removed: - alloy::sol_types::private::Vec<::RustType>, + pub removed: alloy::sol_types::private::Vec< + ::RustType, + >, #[allow(missing_docs)] - pub added: - alloy::sol_types::private::Vec<::RustType>, + pub added: alloy::sol_types::private::Vec< + ::RustType, + >, } #[allow( non_camel_case_types, @@ -2229,15 +2436,45 @@ pub mod PermissionedStakeTable { alloy::sol_types::sol_data::Array, alloy::sol_types::sol_data::Array, ); - type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type DataToken<'a> = as alloy_sol_types::SolType>::Token<'a>; type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,); const SIGNATURE: &'static str = "StakersUpdated((uint256,uint256,uint256,uint256)[],((uint256,uint256,uint256,uint256),(uint256,uint256),bool)[])"; - const SIGNATURE_HASH: alloy_sol_types::private::B256 = - alloy_sol_types::private::B256::new([ - 75u8, 179u8, 28u8, 217u8, 174u8, 135u8, 163u8, 248u8, 40u8, 149u8, 88u8, 199u8, - 155u8, 229u8, 35u8, 37u8, 6u8, 206u8, 54u8, 222u8, 66u8, 105u8, 200u8, 186u8, - 69u8, 52u8, 166u8, 251u8, 233u8, 226u8, 150u8, 93u8, - ]); + const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([ + 75u8, + 179u8, + 28u8, + 217u8, + 174u8, + 135u8, + 163u8, + 248u8, + 40u8, + 149u8, + 88u8, + 199u8, + 155u8, + 229u8, + 35u8, + 37u8, + 6u8, + 206u8, + 54u8, + 222u8, + 66u8, + 105u8, + 200u8, + 186u8, + 69u8, + 52u8, + 166u8, + 251u8, + 233u8, + 226u8, + 150u8, + 93u8, + ]); const ANONYMOUS: bool = false; #[allow(unused_variables)] #[inline] @@ -2255,11 +2492,13 @@ pub mod PermissionedStakeTable { topics: &::RustType, ) -> alloy_sol_types::Result<()> { if topics.0 != Self::SIGNATURE_HASH { - return Err(alloy_sol_types::Error::invalid_event_signature_hash( - Self::SIGNATURE, - topics.0, - Self::SIGNATURE_HASH, - )); + return Err( + alloy_sol_types::Error::invalid_event_signature_hash( + Self::SIGNATURE, + topics.0, + Self::SIGNATURE_HASH, + ), + ); } Ok(()) } @@ -2286,7 +2525,9 @@ pub mod PermissionedStakeTable { if out.len() < ::COUNT { return Err(alloy_sol_types::Error::Overrun); } - out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH); + out[0usize] = alloy_sol_types::abi::token::WordToken( + Self::SIGNATURE_HASH, + ); Ok(()) } } @@ -2308,15 +2549,16 @@ pub mod PermissionedStakeTable { } }; /**Constructor`. - ```solidity - constructor(NodeInfo[] initialStakers); - ```*/ +```solidity +constructor(NodeInfo[] initialStakers); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct constructorCall { #[allow(missing_docs)] - pub initialStakers: - alloy::sol_types::private::Vec<::RustType>, + pub initialStakers: alloy::sol_types::private::Vec< + ::RustType, + >, } const _: () = { use alloy::sol_types as alloy_sol_types; @@ -2325,15 +2567,19 @@ pub mod PermissionedStakeTable { type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Array,); #[doc(hidden)] type UnderlyingRustTuple<'a> = ( - alloy::sol_types::private::Vec<::RustType>, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2347,16 +2593,16 @@ pub mod PermissionedStakeTable { #[doc(hidden)] impl ::core::convert::From> for constructorCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - initialStakers: tuple.0, - } + Self { initialStakers: tuple.0 } } } } #[automatically_derived] impl alloy_sol_types::SolConstructor for constructorCall { type Parameters<'a> = (alloy::sol_types::sol_data::Array,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; #[inline] fn new<'a>( tuple: as alloy_sol_types::SolType>::RustType, @@ -2374,9 +2620,9 @@ pub mod PermissionedStakeTable { } }; /**Function with signature `_hashBlsKey((uint256,uint256,uint256,uint256))` and selector `0x9b30a5e6`. - ```solidity - function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32); - ```*/ +```solidity +function _hashBlsKey(BN254.G2Point memory blsVK) external pure returns (bytes32); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct _hashBlsKeyCall { @@ -2402,15 +2648,18 @@ pub mod PermissionedStakeTable { #[doc(hidden)] type UnderlyingSolTuple<'a> = (BN254::G2Point,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = - (::RustType,); + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2435,11 +2684,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2460,10 +2711,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for _hashBlsKeyCall { type Parameters<'a> = (BN254::G2Point,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = _hashBlsKeyReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "_hashBlsKey((uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [155u8, 48u8, 165u8, 230u8]; #[inline] @@ -2474,26 +2729,24 @@ pub mod PermissionedStakeTable { } #[inline] fn tokenize(&self) -> Self::Token<'_> { - (::tokenize( - &self.blsVK, - ),) + (::tokenize(&self.blsVK),) } #[inline] fn abi_decode_returns( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initialize()` and selector `0x8129fc1c`. - ```solidity - function initialize() external; - ```*/ +```solidity +function initialize() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializeCall {} @@ -2516,11 +2769,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2545,11 +2800,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2570,10 +2827,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for initializeCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializeReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initialize()"; const SELECTOR: [u8; 4] = [129u8, 41u8, 252u8, 28u8]; #[inline] @@ -2591,17 +2852,17 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `initializedAtBlock()` and selector `0x3e9df9b5`. - ```solidity - function initializedAtBlock() external view returns (uint256); - ```*/ +```solidity +function initializedAtBlock() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct initializedAtBlockCall {} @@ -2627,23 +2888,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: initializedAtBlockCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for initializedAtBlockCall { + impl ::core::convert::From> + for initializedAtBlockCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -2653,26 +2918,32 @@ pub mod PermissionedStakeTable { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: initializedAtBlockReturn) -> Self { (value._0,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for initializedAtBlockReturn { + impl ::core::convert::From> + for initializedAtBlockReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { _0: tuple.0 } } @@ -2681,10 +2952,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for initializedAtBlockCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = initializedAtBlockReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "initializedAtBlock()"; const SELECTOR: [u8; 4] = [62u8, 157u8, 249u8, 181u8]; #[inline] @@ -2702,17 +2977,17 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `isStaker((uint256,uint256,uint256,uint256))` and selector `0x75d705e9`. - ```solidity - function isStaker(BN254.G2Point memory staker) external view returns (bool); - ```*/ +```solidity +function isStaker(BN254.G2Point memory staker) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct isStakerCall { @@ -2738,15 +3013,18 @@ pub mod PermissionedStakeTable { #[doc(hidden)] type UnderlyingSolTuple<'a> = (BN254::G2Point,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = - (::RustType,); + type UnderlyingRustTuple<'a> = ( + ::RustType, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2771,11 +3049,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2796,10 +3076,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for isStakerCall { type Parameters<'a> = (BN254::G2Point,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = isStakerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "isStaker((uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [117u8, 215u8, 5u8, 233u8]; #[inline] @@ -2810,26 +3094,24 @@ pub mod PermissionedStakeTable { } #[inline] fn tokenize(&self) -> Self::Token<'_> { - (::tokenize( - &self.staker, - ),) + (::tokenize(&self.staker),) } #[inline] fn abi_decode_returns( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `owner()` and selector `0x8da5cb5b`. - ```solidity - function owner() external view returns (address); - ```*/ +```solidity +function owner() external view returns (address); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct ownerCall {} @@ -2855,11 +3137,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2884,11 +3168,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2909,10 +3195,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for ownerCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = ownerReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "owner()"; const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8]; #[inline] @@ -2930,17 +3220,17 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `renounceOwnership()` and selector `0x715018a6`. - ```solidity - function renounceOwnership() external; - ```*/ +```solidity +function renounceOwnership() external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct renounceOwnershipCall {} @@ -2963,23 +3253,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipCall) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipCall { + impl ::core::convert::From> + for renounceOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -2992,23 +3286,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: renounceOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for renounceOwnershipReturn { + impl ::core::convert::From> + for renounceOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3017,10 +3315,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for renounceOwnershipCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = renounceOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "renounceOwnership()"; const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8]; #[inline] @@ -3038,17 +3340,17 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`. - ```solidity - function transferOwnership(address newOwner) external; - ```*/ +```solidity +function transferOwnership(address newOwner) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct transferOwnershipCall { @@ -3074,23 +3376,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipCall) -> Self { (value.newOwner,) } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipCall { + impl ::core::convert::From> + for transferOwnershipCall { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self { newOwner: tuple.0 } } @@ -3103,23 +3409,27 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From for UnderlyingRustTuple<'_> { + impl ::core::convert::From + for UnderlyingRustTuple<'_> { fn from(value: transferOwnershipReturn) -> Self { () } } #[automatically_derived] #[doc(hidden)] - impl ::core::convert::From> for transferOwnershipReturn { + impl ::core::convert::From> + for transferOwnershipReturn { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { Self {} } @@ -3128,10 +3438,14 @@ pub mod PermissionedStakeTable { #[automatically_derived] impl alloy_sol_types::SolCall for transferOwnershipCall { type Parameters<'a> = (alloy::sol_types::sol_data::Address,); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = transferOwnershipReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "transferOwnership(address)"; const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8]; #[inline] @@ -3153,26 +3467,28 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `update((uint256,uint256,uint256,uint256)[],((uint256,uint256,uint256,uint256),(uint256,uint256),bool)[])` and selector `0xcbba7c78`. - ```solidity - function update(BN254.G2Point[] memory stakersToRemove, NodeInfo[] memory newStakers) external; - ```*/ +```solidity +function update(BN254.G2Point[] memory stakersToRemove, NodeInfo[] memory newStakers) external; +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct updateCall { #[allow(missing_docs)] - pub stakersToRemove: - alloy::sol_types::private::Vec<::RustType>, + pub stakersToRemove: alloy::sol_types::private::Vec< + ::RustType, + >, #[allow(missing_docs)] - pub newStakers: - alloy::sol_types::private::Vec<::RustType>, + pub newStakers: alloy::sol_types::private::Vec< + ::RustType, + >, } ///Container type for the return parameters of the [`update((uint256,uint256,uint256,uint256)[],((uint256,uint256,uint256,uint256),(uint256,uint256),bool)[])`](updateCall) function. #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] @@ -3197,15 +3513,19 @@ pub mod PermissionedStakeTable { alloy::sol_types::private::Vec< ::RustType, >, - alloy::sol_types::private::Vec<::RustType>, + alloy::sol_types::private::Vec< + ::RustType, + >, ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3233,11 +3553,13 @@ pub mod PermissionedStakeTable { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3261,10 +3583,14 @@ pub mod PermissionedStakeTable { alloy::sol_types::sol_data::Array, alloy::sol_types::sol_data::Array, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = updateReturn; type ReturnTuple<'a> = (); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "update((uint256,uint256,uint256,uint256)[],((uint256,uint256,uint256,uint256),(uint256,uint256),bool)[])"; const SELECTOR: [u8; 4] = [203u8, 186u8, 124u8, 120u8]; #[inline] @@ -3289,10 +3615,10 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -3342,19 +3668,23 @@ pub mod PermissionedStakeTable { #[inline] fn selector(&self) -> [u8; 4] { match self { - Self::_hashBlsKey(_) => <_hashBlsKeyCall as alloy_sol_types::SolCall>::SELECTOR, - Self::initialize(_) => ::SELECTOR, + Self::_hashBlsKey(_) => { + <_hashBlsKeyCall as alloy_sol_types::SolCall>::SELECTOR + } + Self::initialize(_) => { + ::SELECTOR + } Self::initializedAtBlock(_) => { ::SELECTOR - }, + } Self::isStaker(_) => ::SELECTOR, Self::owner(_) => ::SELECTOR, Self::renounceOwnership(_) => { ::SELECTOR - }, + } Self::transferOwnership(_) => { ::SELECTOR - }, + } Self::update(_) => ::SELECTOR, } } @@ -3376,17 +3706,17 @@ pub mod PermissionedStakeTable { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn initializedAtBlock( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableCalls::initializedAtBlock) + data, + validate, + ) + .map(PermissionedStakeTableCalls::initializedAtBlock) } initializedAtBlock }, @@ -3396,9 +3726,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableCalls::renounceOwnership) + data, + validate, + ) + .map(PermissionedStakeTableCalls::renounceOwnership) } renounceOwnership }, @@ -3407,7 +3738,10 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PermissionedStakeTableCalls::isStaker) } isStaker @@ -3417,7 +3751,10 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PermissionedStakeTableCalls::initialize) } initialize @@ -3427,7 +3764,10 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PermissionedStakeTableCalls::owner) } owner @@ -3438,9 +3778,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableCalls::_hashBlsKey) + data, + validate, + ) + .map(PermissionedStakeTableCalls::_hashBlsKey) } _hashBlsKey }, @@ -3449,7 +3790,10 @@ pub mod PermissionedStakeTable { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PermissionedStakeTableCalls::update) } update @@ -3460,18 +3804,21 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableCalls::transferOwnership) + data, + validate, + ) + .map(PermissionedStakeTableCalls::transferOwnership) } transferOwnership }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3479,58 +3826,84 @@ pub mod PermissionedStakeTable { fn abi_encoded_size(&self) -> usize { match self { Self::_hashBlsKey(inner) => { - <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encoded_size(inner) - }, + <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encoded_size( + inner, + ) + } Self::initialize(inner) => { ::abi_encoded_size(inner) - }, + } Self::initializedAtBlock(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::isStaker(inner) => { ::abi_encoded_size(inner) - }, + } Self::owner(inner) => { ::abi_encoded_size(inner) - }, + } Self::renounceOwnership(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::transferOwnership(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::update(inner) => { ::abi_encoded_size(inner) - }, + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::_hashBlsKey(inner) => { - <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out) - }, + <_hashBlsKeyCall as alloy_sol_types::SolCall>::abi_encode_raw( + inner, + out, + ) + } Self::initialize(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::initializedAtBlock(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::isStaker(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::owner(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::renounceOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::transferOwnership(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::update(inner) => { ::abi_encode_raw(inner, out) - }, + } } } } @@ -3576,20 +3949,22 @@ pub mod PermissionedStakeTable { match self { Self::InvalidInitialization(_) => { ::SELECTOR - }, + } Self::NotInitializing(_) => { ::SELECTOR - }, + } Self::OwnableInvalidOwner(_) => { ::SELECTOR - }, + } Self::OwnableUnauthorizedAccount(_) => { ::SELECTOR - }, + } Self::StakerAlreadyExists(_) => { ::SELECTOR - }, - Self::StakerNotFound(_) => ::SELECTOR, + } + Self::StakerNotFound(_) => { + ::SELECTOR + } } } #[inline] @@ -3610,17 +3985,19 @@ pub mod PermissionedStakeTable { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn OwnableUnauthorizedAccount( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::OwnableUnauthorizedAccount) + data, + validate, + ) + .map( + PermissionedStakeTableErrors::OwnableUnauthorizedAccount, + ) } OwnableUnauthorizedAccount }, @@ -3630,9 +4007,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::OwnableInvalidOwner) + data, + validate, + ) + .map(PermissionedStakeTableErrors::OwnableInvalidOwner) } OwnableInvalidOwner }, @@ -3642,9 +4020,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::StakerNotFound) + data, + validate, + ) + .map(PermissionedStakeTableErrors::StakerNotFound) } StakerNotFound }, @@ -3654,9 +4033,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::StakerAlreadyExists) + data, + validate, + ) + .map(PermissionedStakeTableErrors::StakerAlreadyExists) } StakerAlreadyExists }, @@ -3666,9 +4046,10 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::NotInitializing) + data, + validate, + ) + .map(PermissionedStakeTableErrors::NotInitializing) } NotInitializing }, @@ -3678,18 +4059,21 @@ pub mod PermissionedStakeTable { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PermissionedStakeTableErrors::InvalidInitialization) + data, + validate, + ) + .map(PermissionedStakeTableErrors::InvalidInitialization) } InvalidInitialization }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3697,50 +4081,76 @@ pub mod PermissionedStakeTable { fn abi_encoded_size(&self) -> usize { match self { Self::InvalidInitialization(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::NotInitializing(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::OwnableInvalidOwner(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::OwnableUnauthorizedAccount(inner) => { ::abi_encoded_size( inner, ) - }, + } Self::StakerAlreadyExists(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::StakerNotFound(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::InvalidInitialization(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::NotInitializing(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::OwnableInvalidOwner(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::OwnableUnauthorizedAccount(inner) => { ::abi_encode_raw( - inner, out, + inner, + out, ) - }, + } Self::StakerAlreadyExists(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::StakerNotFound(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } @@ -3763,19 +4173,106 @@ pub mod PermissionedStakeTable { /// Prefer using `SolInterface` methods instead. pub const SELECTORS: &'static [[u8; 32usize]] = &[ [ - 75u8, 179u8, 28u8, 217u8, 174u8, 135u8, 163u8, 248u8, 40u8, 149u8, 88u8, 199u8, - 155u8, 229u8, 35u8, 37u8, 6u8, 206u8, 54u8, 222u8, 66u8, 105u8, 200u8, 186u8, 69u8, - 52u8, 166u8, 251u8, 233u8, 226u8, 150u8, 93u8, + 75u8, + 179u8, + 28u8, + 217u8, + 174u8, + 135u8, + 163u8, + 248u8, + 40u8, + 149u8, + 88u8, + 199u8, + 155u8, + 229u8, + 35u8, + 37u8, + 6u8, + 206u8, + 54u8, + 222u8, + 66u8, + 105u8, + 200u8, + 186u8, + 69u8, + 52u8, + 166u8, + 251u8, + 233u8, + 226u8, + 150u8, + 93u8, ], [ - 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8, - 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8, - 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8, + 139u8, + 224u8, + 7u8, + 156u8, + 83u8, + 22u8, + 89u8, + 20u8, + 19u8, + 68u8, + 205u8, + 31u8, + 208u8, + 164u8, + 242u8, + 132u8, + 25u8, + 73u8, + 127u8, + 151u8, + 34u8, + 163u8, + 218u8, + 175u8, + 227u8, + 180u8, + 24u8, + 111u8, + 107u8, + 100u8, + 87u8, + 224u8, ], [ - 199u8, 245u8, 5u8, 178u8, 243u8, 113u8, 174u8, 33u8, 117u8, 238u8, 73u8, 19u8, - 244u8, 73u8, 158u8, 31u8, 38u8, 51u8, 167u8, 181u8, 147u8, 99u8, 33u8, 238u8, - 209u8, 205u8, 174u8, 182u8, 17u8, 81u8, 129u8, 210u8, + 199u8, + 245u8, + 5u8, + 178u8, + 243u8, + 113u8, + 174u8, + 33u8, + 117u8, + 238u8, + 73u8, + 19u8, + 244u8, + 73u8, + 158u8, + 31u8, + 38u8, + 51u8, + 167u8, + 181u8, + 147u8, + 99u8, + 33u8, + 238u8, + 209u8, + 205u8, + 174u8, + 182u8, + 17u8, + 81u8, + 129u8, + 210u8, ], ]; } @@ -3791,31 +4288,41 @@ pub mod PermissionedStakeTable { match topics.first().copied() { Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::Initialized) - }, - Some(::SIGNATURE_HASH) => { + topics, + data, + validate, + ) + .map(Self::Initialized) + } + Some( + ::SIGNATURE_HASH, + ) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::OwnershipTransferred) - }, + topics, + data, + validate, + ) + .map(Self::OwnershipTransferred) + } Some(::SIGNATURE_HASH) => { ::decode_raw_log( - topics, data, validate, - ) - .map(Self::StakersUpdated) - }, - _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { - name: ::NAME, - log: alloy_sol_types::private::Box::new( - alloy_sol_types::private::LogData::new_unchecked( - topics.to_vec(), - data.to_vec().into(), + topics, + data, + validate, + ) + .map(Self::StakersUpdated) + } + _ => { + alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog { + name: ::NAME, + log: alloy_sol_types::private::Box::new( + alloy_sol_types::private::LogData::new_unchecked( + topics.to_vec(), + data.to_vec().into(), + ), ), - ), - }), + }) + } } } } @@ -3825,33 +4332,33 @@ pub mod PermissionedStakeTable { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } Self::StakersUpdated(inner) => { alloy_sol_types::private::IntoLogData::to_log_data(inner) - }, + } } } fn into_log_data(self) -> alloy_sol_types::private::LogData { match self { Self::Initialized(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::OwnershipTransferred(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } Self::StakersUpdated(inner) => { alloy_sol_types::private::IntoLogData::into_log_data(inner) - }, + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`PermissionedStakeTable`](self) contract instance. - See the [wrapper's documentation](`PermissionedStakeTableInstance`) for more details.*/ +See the [wrapper's documentation](`PermissionedStakeTableInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3865,9 +4372,9 @@ pub mod PermissionedStakeTable { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3884,10 +4391,10 @@ pub mod PermissionedStakeTable { PermissionedStakeTableInstance::::deploy(provider, initialStakers) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3899,21 +4406,29 @@ pub mod PermissionedStakeTable { ::RustType, >, ) -> alloy_contract::RawCallBuilder { - PermissionedStakeTableInstance::::deploy_builder(provider, initialStakers) + PermissionedStakeTableInstance::< + T, + P, + N, + >::deploy_builder(provider, initialStakers) } /**A [`PermissionedStakeTable`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`PermissionedStakeTable`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`PermissionedStakeTable`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] - pub struct PermissionedStakeTableInstance { + pub struct PermissionedStakeTableInstance< + T, + P, + N = alloy_contract::private::Ethereum, + > { address: alloy_sol_types::private::Address, provider: P, _network_transport: ::core::marker::PhantomData<(N, T)>, @@ -3922,24 +4437,24 @@ pub mod PermissionedStakeTable { impl ::core::fmt::Debug for PermissionedStakeTableInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PermissionedStakeTableInstance") - .field(&self.address) - .finish() + f.debug_tuple("PermissionedStakeTableInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PermissionedStakeTableInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PermissionedStakeTableInstance { /**Creates a new wrapper around an on-chain [`PermissionedStakeTable`](self) contract instance. - See the [wrapper's documentation](`PermissionedStakeTableInstance`) for more details.*/ +See the [wrapper's documentation](`PermissionedStakeTableInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -3948,9 +4463,9 @@ pub mod PermissionedStakeTable { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -3963,10 +4478,10 @@ pub mod PermissionedStakeTable { Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder( provider: P, @@ -3978,12 +4493,12 @@ pub mod PermissionedStakeTable { provider, [ &BYTECODE[..], - &alloy_sol_types::SolConstructor::abi_encode(&constructorCall { - initialStakers, - })[..], + &alloy_sol_types::SolConstructor::abi_encode( + &constructorCall { initialStakers }, + )[..], ] - .concat() - .into(), + .concat() + .into(), ) } /// Returns a reference to the address. @@ -4021,11 +4536,10 @@ pub mod PermissionedStakeTable { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PermissionedStakeTableInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PermissionedStakeTableInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -4044,7 +4558,9 @@ pub mod PermissionedStakeTable { self.call_builder(&_hashBlsKeyCall { blsVK }) } ///Creates a new call builder for the [`initialize`] function. - pub fn initialize(&self) -> alloy_contract::SolCallBuilder { + pub fn initialize( + &self, + ) -> alloy_contract::SolCallBuilder { self.call_builder(&initializeCall {}) } ///Creates a new call builder for the [`initializedAtBlock`] function. @@ -4087,20 +4603,21 @@ pub mod PermissionedStakeTable { ::RustType, >, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&updateCall { - stakersToRemove, - newStakers, - }) + self.call_builder( + &updateCall { + stakersToRemove, + newStakers, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PermissionedStakeTableInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PermissionedStakeTableInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -4111,7 +4628,9 @@ pub mod PermissionedStakeTable { alloy_contract::Event::new_sol(&self.provider, &self.address) } ///Creates a new event filter for the [`Initialized`] event. - pub fn Initialized_filter(&self) -> alloy_contract::Event { + pub fn Initialized_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } ///Creates a new event filter for the [`OwnershipTransferred`] event. @@ -4121,7 +4640,9 @@ pub mod PermissionedStakeTable { self.event_filter::() } ///Creates a new event filter for the [`StakersUpdated`] event. - pub fn StakersUpdated_filter(&self) -> alloy_contract::Event { + pub fn StakersUpdated_filter( + &self, + ) -> alloy_contract::Event { self.event_filter::() } } diff --git a/contract-bindings-alloy/src/plonkverifier.rs b/contract-bindings-alloy/src/plonkverifier.rs index 060d8dccac..9f8f68143b 100644 --- a/contract-bindings-alloy/src/plonkverifier.rs +++ b/contract-bindings-alloy/src/plonkverifier.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -564,12 +621,11 @@ library IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -682,11 +738,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -765,23 +823,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -792,50 +872,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -849,111 +943,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) + .0, + ::eip712_data_word( + &self.wire3, + ) + .0, + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.split1, + ) + .0, + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) + .0, + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1036,7 +1232,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1082,7 +1280,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1130,16 +1329,23 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } - ```*/ +struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct VerifyingKey { @@ -1248,11 +1454,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1361,50 +1569,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for VerifyingKey { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1418,64 +1640,154 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(18); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] @@ -1654,7 +1966,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1688,43 +2002,56 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.q1, out, + &rust.q1, + out, ); ::encode_topic_preimage( - &rust.q2, out, + &rust.q2, + out, ); ::encode_topic_preimage( - &rust.q3, out, + &rust.q3, + out, ); ::encode_topic_preimage( - &rust.q4, out, + &rust.q4, + out, ); ::encode_topic_preimage( - &rust.qM12, out, + &rust.qM12, + out, ); ::encode_topic_preimage( - &rust.qM34, out, + &rust.qM34, + out, ); ::encode_topic_preimage( - &rust.qO, out, + &rust.qO, + out, ); ::encode_topic_preimage( - &rust.qC, out, + &rust.qC, + out, ); ::encode_topic_preimage( - &rust.qH1, out, + &rust.qH1, + out, ); ::encode_topic_preimage( - &rust.qH2, out, + &rust.qH2, + out, ); ::encode_topic_preimage( - &rust.qH3, out, + &rust.qH3, + out, ); ::encode_topic_preimage( - &rust.qH4, out, + &rust.qH4, + out, ); ::encode_topic_preimage( - &rust.qEcc, out, + &rust.qEcc, + out, ); alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1764,15 +2098,15 @@ pub mod IPlonkVerifier { } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -1783,24 +2117,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1842,11 +2176,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -1861,11 +2194,10 @@ pub mod IPlonkVerifier { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -2609,9 +2941,8 @@ interface PlonkVerifier { clippy::empty_structs_with_brackets )] pub mod PlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -2633,9 +2964,9 @@ pub mod PlonkVerifier { b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10a\x004W_5`\xE0\x1C\x80c\xCESzw\x14a\08W[_\x80\xFD[a\0Ka\0F6`\x04a 3V[a\0_V[`@Q\x90\x15\x15\x81R` \x01`@Q\x80\x91\x03\x90\xF3[_a\0i\x82a\0\xD0V[a\0y\x83_[` \x02\x01Qa\x02\x0BV[a\0\x84\x83`\x01a\0oV[a\0\x8F\x83`\x02a\0oV[a\0\x9A\x83`\x03a\0oV[a\0\xA5\x83`\x04a\0oV[a\0\xB0\x83`\x05a\0oV[a\0\xBB\x83`\x06a\0oV[a\0\xC6\x84\x84\x84a\x02qV[\x90P[\x93\x92PPPV[\x80Qa\0\xDB\x90a\x04eV[a\0\xE8\x81` \x01Qa\x04eV[a\0\xF5\x81`@\x01Qa\x04eV[a\x01\x02\x81``\x01Qa\x04eV[a\x01\x0F\x81`\x80\x01Qa\x04eV[a\x01\x1C\x81`\xA0\x01Qa\x04eV[a\x01)\x81`\xC0\x01Qa\x04eV[a\x016\x81`\xE0\x01Qa\x04eV[a\x01D\x81a\x01\0\x01Qa\x04eV[a\x01R\x81a\x01 \x01Qa\x04eV[a\x01`\x81a\x01@\x01Qa\x04eV[a\x01n\x81a\x01`\x01Qa\x04eV[a\x01|\x81a\x01\x80\x01Qa\x04eV[a\x01\x8A\x81a\x01\xA0\x01Qa\x02\x0BV[a\x01\x98\x81a\x01\xC0\x01Qa\x02\x0BV[a\x01\xA6\x81a\x01\xE0\x01Qa\x02\x0BV[a\x01\xB4\x81a\x02\0\x01Qa\x02\x0BV[a\x01\xC2\x81a\x02 \x01Qa\x02\x0BV[a\x01\xD0\x81a\x02@\x01Qa\x02\x0BV[a\x01\xDE\x81a\x02`\x01Qa\x02\x0BV[a\x01\xEC\x81a\x02\x80\x01Qa\x02\x0BV[a\x01\xFA\x81a\x02\xA0\x01Qa\x02\x0BV[a\x02\x08\x81a\x02\xC0\x01Qa\x02\x0BV[PV[_\x80Q` a\"x\x839\x81Q\x91R\x81\x10\x80a\x02mW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FBn254: invalid scalar field\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[PPV[_\x83` \x01Q`\x07\x14a\x02\x97W`@Qc \xFA\x9D\x89`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_a\x02\xA3\x85\x85\x85a\x05\x13V[\x90P_a\x02\xB2\x86_\x01Qa\nsV[\x90P_a\x02\xC4\x82\x84`\xA0\x01Q\x88a\x0EQV[\x90Pa\x02\xE1`@Q\x80`@\x01`@R\x80_\x81R` \x01_\x81RP\x90V[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x03\x15\x87a\x01`\x01Qa\x03\x10\x89a\x01\x80\x01Q\x88`\xE0\x01Qa\x0E\xAEV[a\x0FOV[\x91P_\x80a\x03%\x8B\x88\x87\x8Ca\x0F\xF3V[\x91P\x91Pa\x036\x81a\x03\x10\x84a\x12+V[\x92Pa\x03O\x83a\x03\x10\x8Ba\x01`\x01Q\x8A`\xA0\x01Qa\x0E\xAEV[`\xA0\x88\x01Q`@\x88\x01Q` \x01Q\x91\x94P_\x80Q` a\"x\x839\x81Q\x91R\x91\x82\x90\x82\t\x90P\x81`\xE0\x8A\x01Q\x82\t\x90Pa\x03\x92\x85a\x03\x10\x8Da\x01\x80\x01Q\x84a\x0E\xAEV[\x94P_`@Q\x80`\x80\x01`@R\x80\x7F\x01\x18\xC4\xD5\xB87\xBC\xC2\xBC\x89\xB5\xB3\x98\xB5\x97N\x9FYD\x07;2\x07\x8B~#\x1F\xEC\x93\x88\x83\xB0\x81R` \x01\x7F&\x0E\x01\xB2Q\xF6\xF1\xC7\xE7\xFFNX\x07\x91\xDE\xE8\xEAQ\xD8z5\x8E\x03\x8BN\xFE0\xFA\xC0\x93\x83\xC1\x81R` \x01\x7F\"\xFE\xBD\xA3\xC0\xC0c*VG[B\x14\xE5a^\x11\xE6\xDD?\x96\xE6\xCE\xA2\x85J\x87\xD4\xDA\xCC^U\x81R` \x01\x7F\x04\xFCci\xF7\x11\x0F\xE3\xD2QV\xC1\xBB\x9Ar\x85\x9C\xF2\xA0FA\xF9\x9B\xA4\xEEA<\x80\xDAj_\xE4\x81RP\x90Pa\x04S\x87\x82a\x04F\x89a\x12+V[a\x04Na\x12\xC8V[a\x13\x95V[\x9E\x9DPPPPPPPPPPPPPPV[\x80Q` \x82\x01Q_\x91\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\x91\x15\x90\x15\x16\x15a\x04\x9EWPPPV[\x82Q` \x84\x01Q\x82`\x03\x84\x85\x85\x86\t\x85\t\x08\x83\x82\x83\t\x14\x83\x82\x10\x84\x84\x10\x16\x16\x93PPP\x81a\x05\x0EW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FBn254: invalid G1 point\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02dV[PPPV[a\x05S`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[__\x80Q` a\"x\x839\x81Q\x91R\x90P`@Q` \x81\x01_\x81R`\xFE`\xE0\x1B\x81R\x86Q`\xC0\x1B`\x04\x82\x01R` \x87\x01Q`\xC0\x1B`\x0C\x82\x01Ra\x02\x80\x87\x01Q` \x82\x01Ra\x02\xA0\x87\x01Q`@\x82\x01R`\x01``\x82\x01R\x7F/\x8D\xD1\xF1\xA7X\xA8\x01f\x9Cd\x01q \xE1t \xAA\xE6\xAD\xAA\x01\xC2a|n\x85\x81R` \x01\x7F\x12YzV\xC2\xE48b\x0B\x90A\xB9\x89\x92\xAE\rNp[x\0W\xBFwf\xA2v|\xEC\xE1n\x1D\x81R` \x01\x7F\x02\xD9A\x17\xCD\x17\xBC\xF1)\x0F\xD6|\x01\x15]\xD4\x08\x07\x85}\xFFJZ\x0BM\xC6{\xEF\xA8\xAA4\xFD\x81RP\x81RP\x90P\x91\x90PV[\x81b\x10\0\0\x03a\x0C\xFAW`@Q\x80``\x01`@R\x80`\x14\x81R` \x01\x7F0dKl\x9CJr\x16\x9EM\xAA1}%\xF0E\x12\xAE\x15\xC5;4\xE8\xF5\xAC\xD8\xE1U\xD0\xA6\xC1\x01\x81R` \x01`@Q\x80`\xE0\x01`@R\x80`\x01\x81R` \x01\x7F&\x12]\xA1\n\x0E\xD0c'P\x8A\xBA\x06\xD1\xE3\x03\xACaf2\xDB\xED4\x9FSB-\xA9S3xW\x81R` \x01\x7F\"`\xE7$\x84K\xCARQ\x82\x93S\x96\x8EI\x150RXA\x83WG:\\\x1DY\x7Fa?l\xBD\x81R` \x01\x7F \x87\xEA,\xD6d'\x86\x08\xFB\x0E\xBD\xB8 \x90\x7FY\x85\x02\xC8\x1Bf\x90\xC1\x85\xE2\xBF\x15\xCB\x93_B\x81R` \x01\x7F\x19\xDD\xBC\xAF:\x8DF\xC1\\\x01v\xFB\xB5\xB9^M\xC5p\x88\xFF\x13\xF4\xD1\xBD\x84\xC6\xBF\xA5}\xCD\xC0\xE0\x81R` \x01\x7F\x05\xA2\xC8\\\xFCY\x17\x89`\\\xAE\x81\x8E7\xDDAa\xEE\xF9\xAAfk\xECo\xE4(\x8D\t\xE6\xD24\x18\x81R` \x01\x7F\x11\xF7\x0ESc%\x8F\xF4\xF0\xD7\x16\xA6S\xE1\xDCA\xF1\xC6D\x84\xD7\xF4\xB6\xE2\x19\xD67v\x14\xA3\x90\\\x81RP\x81RP\x90P\x91\x90PV[\x81` \x03a\x0E8W`@Q\x80``\x01`@R\x80`\x05\x81R` \x01\x7F.\xE1+\xFFJ(\x13(j\x8D\xC3\x88\xCDuM\x9A>\xF2I\x065\xEB\xA5\x0C\xB9\xC2\xE5\xE7P\x80\0\x01\x81R` \x01`@Q\x80`\xE0\x01`@R\x80`\x01\x81R` \x01\x7F\t\xC52\xC60k\x93\xD2\x96x \rG\xC0\xB2\xA9\x9C\x18\xD5\x1B\x83\x8E\xEB\x1D>\xEDLS;\xB5\x12\xD0\x81R` \x01\x7F!\x08,\xA2\x16\xCB\xBFN\x1CnOE\x94\xDDP\x8C\x99m\xFB\xE1\x17N\xFB\x98\xB1\x15\t\xC6\xE3\x06F\x0B\x81R` \x01\x7F\x12w\xAEd\x15\xF0\xEF\x18\xF2\xBA_\xB1b\xC3\x9E\xB71\x1F8n-&\xD6D\x01\xF4\xA2]\xA7|%;\x81R` \x01\x7F+3}\xE1\xC8\xC1O\"\xEC\x9B\x9E/\x96\xAF\xEF6Rbsf\xF8\x17\n\n\x94\x8D\xADJ\xC1\xBD^\x80\x81R` \x01\x7F/\xBDM\xD2\x97k\xE5]\x1A\x16:\xA9\x82\x0F\xB8\x8D\xFA\xC5\xDD\xCEw\xE1\x87.\x90c '2z^\xBE\x81R` \x01\x7F\x10z\xABI\xE6Zg\xF9\xDA\x9C\xD2\xAB\xF7\x8B\xE3\x8B\xD9\xDC\x1D]\xB3\x9F\x81\xDE6\xBC\xFA[K\x03\x90C\x81RP\x81RP\x90P\x91\x90PV[`@Qc\xE2\xEF\t\xE5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x0Er`@Q\x80``\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81RP\x90V[a\x0E|\x84\x84a\x14uV[\x80\x82Ra\x0E\x8C\x90\x85\x90\x85\x90a\x14\xC6V[` \x82\x01R\x80Qa\x0E\xA2\x90\x85\x90\x84\x90\x86\x90a\x155V[`@\x82\x01R\x93\x92PPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x0E\xC9a\x1D2V[\x83Q\x81R` \x80\x85\x01Q\x90\x82\x01R`@\x81\x01\x83\x90R_``\x83`\x80\x84`\x07a\x07\xD0Z\x03\xFA\x90P\x80\x80a\x0E\xF9W_\x80\xFD[P\x80a\x0FGW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x19`$\x82\x01R\x7FBn254: scalar mul failed!\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x02dV[PP\x92\x91PPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01Ra\x0Fja\x1DPV[\x83Q\x81R` \x80\x85\x01Q\x81\x83\x01R\x83Q`@\x83\x01R\x83\x01Q``\x80\x83\x01\x91\x90\x91R_\x90\x83`\xC0\x84`\x06a\x07\xD0Z\x03\xFA\x90P\x80\x80a\x0F\xA5W_\x80\xFD[P\x80a\x0FGW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FBn254: group addition failed!\0\0\0`D\x82\x01R`d\x01a\x02dV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_a\x10&\x87\x87\x87\x87a\x16\x83V[\x90P_\x80Q` a\"x\x839\x81Q\x91R_a\x10B\x88\x87\x89a\x1BMV[\x90Pa\x10N\x81\x83a\"%V[`\xC0\x89\x01Qa\x01\xA0\x88\x01Q\x91\x92P\x90\x81\x90\x84\x90\x81\x90\x83\t\x84\x08\x92Pa\x10z\x85a\x03\x10\x8A_\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x01\xC0\x8A\x01Q\x83\t\x84\x08\x92Pa\x10\xA2\x86a\x03\x10\x8A` \x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x01\xE0\x8A\x01Q\x83\t\x84\x08\x92Pa\x10\xCA\x86a\x03\x10\x8A`@\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02\0\x8A\x01Q\x83\t\x84\x08\x92Pa\x10\xF2\x86a\x03\x10\x8A``\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02 \x8A\x01Q\x83\t\x84\x08\x92Pa\x11\x1A\x86a\x03\x10\x8A`\x80\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02@\x8A\x01Q\x83\t\x84\x08\x92Pa\x11B\x86a\x03\x10\x8D`@\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02`\x8A\x01Q\x83\t\x84\x08\x92Pa\x11j\x86a\x03\x10\x8D``\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02\x80\x8A\x01Q\x83\t\x84\x08\x92Pa\x11\x92\x86a\x03\x10\x8D`\x80\x01Q\x84a\x0E\xAEV[\x95P\x83\x82\x82\t\x90P\x83\x84a\x02\xA0\x8A\x01Q\x83\t\x84\x08\x92Pa\x11\xBA\x86a\x03\x10\x8D`\xA0\x01Q\x84a\x0E\xAEV[\x95P_\x8A`\xE0\x01Q\x90P\x84\x85a\x02\xC0\x8B\x01Q\x83\t\x85\x08\x93Pa\x11\xE4\x87a\x03\x10\x8B`\xA0\x01Q\x84a\x0E\xAEV[\x96Pa\x12\x1Aa\x12\x14`@\x80Q\x80\x82\x01\x82R_\x80\x82R` \x91\x82\x01R\x81Q\x80\x83\x01\x90\x92R`\x01\x82R`\x02\x90\x82\x01R\x90V[\x85a\x0E\xAEV[\x97PPPPPPP\x94P\x94\x92PPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R\x81Q` \x83\x01Q\x15\x90\x15\x16\x15a\x12RWP\x90V[`@Q\x80`@\x01`@R\x80\x83_\x01Q\x81R` \x01\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\x84` \x01Qa\x12\x96\x91\x90a\"XV[a\x12\xC0\x90\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDGa\"%V[\x90R\x92\x91PPV[a\x12\xEF`@Q\x80`\x80\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[`@Q\x80`\x80\x01`@R\x80\x7F\x18\0\xDE\xEF\x12\x1F\x1EvBj\0f^\\DygC\"\xD4\xF7^\xDA\xDDF\xDE\xBD\\\xD9\x92\xF6\xED\x81R` \x01\x7F\x19\x8E\x93\x93\x92\rH:r`\xBF\xB71\xFB]%\xF1\xAAI35\xA9\xE7\x12\x97\xE4\x85\xB7\xAE\xF3\x12\xC2\x81R` \x01\x7F\x12\xC8^\xA5\xDB\x8Cm\xEBJ\xABq\x80\x8D\xCB@\x8F\xE3\xD1\xE7i\x0CC\xD3{L\xE6\xCC\x01f\xFA}\xAA\x81R` \x01\x7F\t\x06\x89\xD0X_\xF0u\xEC\x9E\x99\xADi\x0C3\x95\xBCK13p\xB3\x8E\xF3U\xAC\xDA\xDC\xD1\"\x97[\x81RP\x90P\x90V[_\x80_`@Q\x87Q\x81R` \x88\x01Q` \x82\x01R` \x87\x01Q`@\x82\x01R\x86Q``\x82\x01R``\x87\x01Q`\x80\x82\x01R`@\x87\x01Q`\xA0\x82\x01R\x85Q`\xC0\x82\x01R` \x86\x01Q`\xE0\x82\x01R` \x85\x01Qa\x01\0\x82\x01R\x84Qa\x01 \x82\x01R``\x85\x01Qa\x01@\x82\x01R`@\x85\x01Qa\x01`\x82\x01R` _a\x01\x80\x83`\x08Z\xFA\x91PP_Q\x91P\x80a\x14gW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1C`$\x82\x01R\x7FBn254: Pairing check failed!\0\0\0\0`D\x82\x01R`d\x01a\x02dV[P\x15\x15\x90P[\x94\x93PPPPV[\x81Q_\x90_\x80Q` a\"x\x839\x81Q\x91R\x90\x83\x80\x15a\x14\xB6W\x84\x93P_[\x82\x81\x10\x15a\x14\xAAW\x83\x85\x86\t\x94P`\x01\x01a\x14\x94V[P`\x01\x84\x03\x93Pa\x14\xBDV[`\x01\x83\x03\x93P[PPP\x92\x91PPV[_\x82`\x01\x03a\x14\xD7WP`\x01a\0\xC9V[\x81_\x03a\x14\xE5WP_a\0\xC9V[` \x84\x01Q_\x80Q` a\"x\x839\x81Q\x91R\x90_\x90\x82\x81\x86\t\x90P\x85\x80\x15a\x15\x13W`\x01\x87\x03\x92Pa\x15\x1AV[`\x01\x84\x03\x92P[Pa\x15$\x82a\x1C8V[\x91P\x82\x82\x82\t\x97\x96PPPPPPPV[__\x80Q` a\"x\x839\x81Q\x91R\x82\x82\x03a\x15\xAEW`\x01_[`\x07\x81\x10\x15a\x15\xA3W\x81\x86\x03a\x15\x80W\x86\x81`\x07\x81\x10a\x15qWa\x15qa\"\x11V[` \x02\x01Q\x93PPPPa\x14mV[\x82\x80a\x15\x8EWa\x15\x8Ea\"DV[`@\x89\x01Q` \x01Q\x83\t\x91P`\x01\x01a\x15OV[P_\x92PPPa\x14mV[a\x15\xB6a\x1DnV[`@\x87\x01Q`\x01`\xC0\x83\x81\x01\x82\x81R\x92\x01\x90\x80[`\x07\x81\x10\x15a\x15\xF7W` \x84\x03\x93P\x85\x86\x8A\x85Q\x89\x03\x08\x83\t\x80\x85R`\x1F\x19\x90\x93\x01\x92\x91P`\x01\x01a\x15\xCAV[PPPP_\x80_\x90P`\x01\x83\x89`@\x8C\x01Q_[`\x07\x81\x10\x15a\x16KW\x88\x82Q\x8A\x85Q\x8C\x88Q\x8A\t\t\t\x89\x81\x88\x08\x96PP\x88\x89\x8D\x84Q\x8C\x03\x08\x86\t\x94P` \x93\x84\x01\x93\x92\x83\x01\x92\x91\x90\x91\x01\x90`\x01\x01a\x16\x0BV[PPPP\x80\x92PP_a\x16]\x83a\x1C8V[\x90P` \x8A\x01Q\x85\x81\x89\t\x96PP\x84\x81\x87\t\x95P\x84\x82\x87\t\x9A\x99PPPPPPPPPPV[`@\x80Q\x80\x82\x01\x90\x91R_\x80\x82R` \x82\x01R_\x80_\x80__\x80Q` a\"x\x839\x81Q\x91R\x90P`\x80\x89\x01Q\x81` \x8A\x01Q` \x8C\x01Q\t\x95P\x89Q\x94P\x81`\xA0\x8B\x01Q``\x8C\x01Q\t\x93P\x81a\x01\xA0\x89\x01Q\x85\x08\x92P\x81\x81\x84\x08\x92P\x81\x85\x84\t\x94P\x81\x7F/\x8D\xD1\xF1\xA7X = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2677,7 +3010,9 @@ pub mod PlonkVerifier { #[automatically_derived] impl alloy_sol_types::SolError for InvalidPlonkArgs { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "InvalidPlonkArgs()"; const SELECTOR: [u8; 4] = [253u8, 154u8, 45u8, 27u8]; #[inline] @@ -2693,9 +3028,9 @@ pub mod PlonkVerifier { } }; /**Custom error with signature `UnsupportedDegree()` and selector `0xe2ef09e5`. - ```solidity - error UnsupportedDegree(); - ```*/ +```solidity +error UnsupportedDegree(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UnsupportedDegree {} @@ -2713,11 +3048,13 @@ pub mod PlonkVerifier { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2737,7 +3074,9 @@ pub mod PlonkVerifier { #[automatically_derived] impl alloy_sol_types::SolError for UnsupportedDegree { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UnsupportedDegree()"; const SELECTOR: [u8; 4] = [226u8, 239u8, 9u8, 229u8]; #[inline] @@ -2753,9 +3092,9 @@ pub mod PlonkVerifier { } }; /**Custom error with signature `WrongPlonkVK()` and selector `0x41f53b12`. - ```solidity - error WrongPlonkVK(); - ```*/ +```solidity +error WrongPlonkVK(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct WrongPlonkVK {} @@ -2773,11 +3112,13 @@ pub mod PlonkVerifier { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2797,7 +3138,9 @@ pub mod PlonkVerifier { #[automatically_derived] impl alloy_sol_types::SolError for WrongPlonkVK { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "WrongPlonkVK()"; const SELECTOR: [u8; 4] = [65u8, 245u8, 59u8, 18u8]; #[inline] @@ -2813,9 +3156,9 @@ pub mod PlonkVerifier { } }; /**Function with signature `verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[7],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x77ae3f07`. - ```solidity - function verify(IPlonkVerifier.VerifyingKey memory verifyingKey, uint256[7] memory publicInput, IPlonkVerifier.PlonkProof memory proof) external view returns (bool); - ```*/ +```solidity +function verify(IPlonkVerifier.VerifyingKey memory verifyingKey, uint256[7] memory publicInput, IPlonkVerifier.PlonkProof memory proof) external view returns (bool); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct verifyCall { @@ -2859,11 +3202,13 @@ pub mod PlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2892,11 +3237,13 @@ pub mod PlonkVerifier { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2924,10 +3271,14 @@ pub mod PlonkVerifier { >, IPlonkVerifier::PlonkProof, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = verifyReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[7],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [119u8, 174u8, 63u8, 7u8]; #[inline] @@ -2946,7 +3297,9 @@ pub mod PlonkVerifier { alloy::sol_types::sol_data::Uint<256>, 7usize, > as alloy_sol_types::SolType>::tokenize(&self.publicInput), - ::tokenize(&self.proof), + ::tokenize( + &self.proof, + ), ) } #[inline] @@ -2954,10 +3307,10 @@ pub mod PlonkVerifier { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -3005,22 +3358,28 @@ pub mod PlonkVerifier { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[{ - fn verify( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) - .map(PlonkVerifierCalls::verify) - } - verify - }]; + ) -> alloy_sol_types::Result] = &[ + { + fn verify( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, + ) + .map(PlonkVerifierCalls::verify) + } + verify + }, + ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3029,7 +3388,7 @@ pub mod PlonkVerifier { match self { Self::verify(inner) => { ::abi_encoded_size(inner) - }, + } } } #[inline] @@ -3037,7 +3396,7 @@ pub mod PlonkVerifier { match self { Self::verify(inner) => { ::abi_encode_raw(inner, out) - }, + } } } } @@ -3074,11 +3433,13 @@ pub mod PlonkVerifier { match self { Self::InvalidPlonkArgs(_) => { ::SELECTOR - }, + } Self::UnsupportedDegree(_) => { ::SELECTOR - }, - Self::WrongPlonkVK(_) => ::SELECTOR, + } + Self::WrongPlonkVK(_) => { + ::SELECTOR + } } } #[inline] @@ -3099,14 +3460,16 @@ pub mod PlonkVerifier { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn WrongPlonkVK( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PlonkVerifierErrors::WrongPlonkVK) } WrongPlonkVK @@ -3117,9 +3480,10 @@ pub mod PlonkVerifier { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PlonkVerifierErrors::UnsupportedDegree) + data, + validate, + ) + .map(PlonkVerifierErrors::UnsupportedDegree) } UnsupportedDegree }, @@ -3129,18 +3493,21 @@ pub mod PlonkVerifier { validate: bool, ) -> alloy_sol_types::Result { ::abi_decode_raw( - data, validate, - ) - .map(PlonkVerifierErrors::InvalidPlonkArgs) + data, + validate, + ) + .map(PlonkVerifierErrors::InvalidPlonkArgs) } InvalidPlonkArgs }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3148,35 +3515,48 @@ pub mod PlonkVerifier { fn abi_encoded_size(&self) -> usize { match self { Self::InvalidPlonkArgs(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::UnsupportedDegree(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } Self::WrongPlonkVK(inner) => { ::abi_encoded_size(inner) - }, + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::InvalidPlonkArgs(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::UnsupportedDegree(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } Self::WrongPlonkVK(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`PlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`PlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`PlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3190,9 +3570,9 @@ pub mod PlonkVerifier { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3200,36 +3580,35 @@ pub mod PlonkVerifier { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { PlonkVerifierInstance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { PlonkVerifierInstance::::deploy_builder(provider) } /**A [`PlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`PlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`PlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct PlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -3240,24 +3619,24 @@ pub mod PlonkVerifier { impl ::core::fmt::Debug for PlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("PlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`PlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`PlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`PlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -3266,20 +3645,22 @@ pub mod PlonkVerifier { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] - pub async fn deploy(provider: P) -> alloy_contract::Result> { + pub async fn deploy( + provider: P, + ) -> alloy_contract::Result> { let call_builder = Self::deploy_builder(provider); let contract_address = call_builder.deploy().await?; Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -3322,11 +3703,10 @@ pub mod PlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -3344,21 +3724,22 @@ pub mod PlonkVerifier { publicInput: [alloy::sol_types::private::primitives::aliases::U256; 7usize], proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&verifyCall { - verifyingKey, - publicInput, - proof, - }) + self.call_builder( + &verifyCall { + verifyingKey, + publicInput, + proof, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. diff --git a/contract-bindings-alloy/src/plonkverifier2.rs b/contract-bindings-alloy/src/plonkverifier2.rs index 1997d2f3bb..ea8bbc93cb 100644 --- a/contract-bindings-alloy/src/plonkverifier2.rs +++ b/contract-bindings-alloy/src/plonkverifier2.rs @@ -16,9 +16,8 @@ library BN254 { clippy::empty_structs_with_brackets )] pub mod BN254 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct BaseField(alloy::sol_types::private::primitives::aliases::U256); @@ -26,24 +25,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -61,12 +65,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -85,11 +93,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for BaseField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -99,15 +109,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -128,10 +138,12 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; @@ -142,24 +154,29 @@ pub mod BN254 { use alloy::sol_types as alloy_sol_types; #[automatically_derived] impl alloy_sol_types::private::SolTypeValue - for alloy::sol_types::private::primitives::aliases::U256 - { + for alloy::sol_types::private::primitives::aliases::U256 { #[inline] fn stv_to_tokens( &self, - ) -> as alloy_sol_types::SolType>::Token<'_> - { + ) -> as alloy_sol_types::SolType>::Token<'_> { alloy_sol_types::private::SolTypeValue::< alloy::sol_types::sol_data::Uint<256>, >::stv_to_tokens(self) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { - as alloy_sol_types::SolType>::tokenize(self) + as alloy_sol_types::SolType>::tokenize(self) .0 } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { as alloy_sol_types::SolType>::abi_encode_packed_to(self, out) @@ -177,12 +194,16 @@ pub mod BN254 { pub const NAME: &'static str = stringify!(@ name); /// Convert from the underlying value type. #[inline] - pub const fn from(value: alloy::sol_types::private::primitives::aliases::U256) -> Self { + pub const fn from( + value: alloy::sol_types::private::primitives::aliases::U256, + ) -> Self { Self(value) } /// Return the underlying value. #[inline] - pub const fn into(self) -> alloy::sol_types::private::primitives::aliases::U256 { + pub const fn into( + self, + ) -> alloy::sol_types::private::primitives::aliases::U256 { self.0 } /// Return the single encoding of this value, delegating to the @@ -201,11 +222,13 @@ pub mod BN254 { #[automatically_derived] impl alloy_sol_types::SolType for ScalarField { type RustType = alloy::sol_types::private::primitives::aliases::U256; - type Token<'a> = - as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = Self::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; @@ -215,15 +238,15 @@ pub mod BN254 { } #[inline] fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> { - as alloy_sol_types::SolType>::type_check( - token, - ) + as alloy_sol_types::SolType>::type_check(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - as alloy_sol_types::SolType>::detokenize( - token, - ) + as alloy_sol_types::SolType>::detokenize(token) } } #[automatically_derived] @@ -244,16 +267,18 @@ pub mod BN254 { > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out) } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { - as alloy_sol_types::EventTopic>::encode_topic( - rust, - ) + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { + as alloy_sol_types::EventTopic>::encode_topic(rust) } } }; /**```solidity - struct G1Point { BaseField x; BaseField y; } - ```*/ +struct G1Point { BaseField x; BaseField y; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct G1Point { @@ -279,11 +304,13 @@ pub mod BN254 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -297,10 +324,7 @@ pub mod BN254 { #[doc(hidden)] impl ::core::convert::From> for G1Point { fn from(tuple: UnderlyingRustTuple<'_>) -> Self { - Self { - x: tuple.0, - y: tuple.1, - } + Self { x: tuple.0, y: tuple.1 } } } #[automatically_derived] @@ -321,50 +345,64 @@ pub mod BN254 { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for G1Point { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -376,9 +414,9 @@ pub mod BN254 { alloy_sol_types::private::Cow::Borrowed("G1Point(uint256 x,uint256 y)") } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { alloy_sol_types::private::Vec::new() } #[inline] @@ -391,7 +429,7 @@ pub mod BN254 { ::eip712_data_word(&self.x).0, ::eip712_data_word(&self.y).0, ] - .concat() + .concat() } } #[automatically_derived] @@ -399,30 +437,49 @@ pub mod BN254 { #[inline] fn topic_preimage_length(rust: &Self::RustType) -> usize { 0usize - + ::topic_preimage_length(&rust.x) - + ::topic_preimage_length(&rust.y) + + ::topic_preimage_length( + &rust.x, + ) + + ::topic_preimage_length( + &rust.y, + ) } #[inline] fn encode_topic_preimage( rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); - ::encode_topic_preimage(&rust.x, out); - ::encode_topic_preimage(&rust.y, out); + out.reserve( + ::topic_preimage_length(rust), + ); + ::encode_topic_preimage( + &rust.x, + out, + ); + ::encode_topic_preimage( + &rust.y, + out, + ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -436,15 +493,15 @@ pub mod BN254 { } /**A [`BN254`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`BN254`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`BN254`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct BN254Instance { address: alloy_sol_types::private::Address, @@ -461,16 +518,18 @@ pub mod BN254 { /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /**Creates a new wrapper around an on-chain [`BN254`](self) contract instance. - See the [wrapper's documentation](`BN254Instance`) for more details.*/ +See the [wrapper's documentation](`BN254Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -512,11 +571,10 @@ pub mod BN254 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -531,11 +589,10 @@ pub mod BN254 { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > BN254Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > BN254Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -564,12 +621,11 @@ library IPlonkVerifier { clippy::empty_structs_with_brackets )] pub mod IPlonkVerifier { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /**```solidity - struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } - ```*/ +struct PlonkProof { BN254.G1Point wire0; BN254.G1Point wire1; BN254.G1Point wire2; BN254.G1Point wire3; BN254.G1Point wire4; BN254.G1Point prodPerm; BN254.G1Point split0; BN254.G1Point split1; BN254.G1Point split2; BN254.G1Point split3; BN254.G1Point split4; BN254.G1Point zeta; BN254.G1Point zetaOmega; BN254.ScalarField wireEval0; BN254.ScalarField wireEval1; BN254.ScalarField wireEval2; BN254.ScalarField wireEval3; BN254.ScalarField wireEval4; BN254.ScalarField sigmaEval0; BN254.ScalarField sigmaEval1; BN254.ScalarField sigmaEval2; BN254.ScalarField sigmaEval3; BN254.ScalarField prodPermZetaOmegaEval; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct PlonkProof { @@ -682,11 +738,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -765,23 +823,45 @@ pub mod IPlonkVerifier { ::tokenize(&self.wire2), ::tokenize(&self.wire3), ::tokenize(&self.wire4), - ::tokenize(&self.prodPerm), + ::tokenize( + &self.prodPerm, + ), ::tokenize(&self.split0), ::tokenize(&self.split1), ::tokenize(&self.split2), ::tokenize(&self.split3), ::tokenize(&self.split4), ::tokenize(&self.zeta), - ::tokenize(&self.zetaOmega), - ::tokenize(&self.wireEval0), - ::tokenize(&self.wireEval1), - ::tokenize(&self.wireEval2), - ::tokenize(&self.wireEval3), - ::tokenize(&self.wireEval4), - ::tokenize(&self.sigmaEval0), - ::tokenize(&self.sigmaEval1), - ::tokenize(&self.sigmaEval2), - ::tokenize(&self.sigmaEval3), + ::tokenize( + &self.zetaOmega, + ), + ::tokenize( + &self.wireEval0, + ), + ::tokenize( + &self.wireEval1, + ), + ::tokenize( + &self.wireEval2, + ), + ::tokenize( + &self.wireEval3, + ), + ::tokenize( + &self.wireEval4, + ), + ::tokenize( + &self.sigmaEval0, + ), + ::tokenize( + &self.sigmaEval1, + ), + ::tokenize( + &self.sigmaEval2, + ), + ::tokenize( + &self.sigmaEval3, + ), ::tokenize( &self.prodPermZetaOmegaEval, ), @@ -792,50 +872,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for PlonkProof { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -849,111 +943,213 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(13); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); + .extend( + ::eip712_components(), + ); components } #[inline] fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec { [ - ::eip712_data_word(&self.wire0).0, - ::eip712_data_word(&self.wire1).0, - ::eip712_data_word(&self.wire2).0, - ::eip712_data_word(&self.wire3).0, - ::eip712_data_word(&self.wire4).0, - ::eip712_data_word(&self.prodPerm) + ::eip712_data_word( + &self.wire0, + ) + .0, + ::eip712_data_word( + &self.wire1, + ) + .0, + ::eip712_data_word( + &self.wire2, + ) + .0, + ::eip712_data_word( + &self.wire3, + ) .0, - ::eip712_data_word(&self.split0).0, - ::eip712_data_word(&self.split1).0, - ::eip712_data_word(&self.split2).0, - ::eip712_data_word(&self.split3).0, - ::eip712_data_word(&self.split4).0, - ::eip712_data_word(&self.zeta).0, - ::eip712_data_word(&self.zetaOmega) + ::eip712_data_word( + &self.wire4, + ) + .0, + ::eip712_data_word( + &self.prodPerm, + ) + .0, + ::eip712_data_word( + &self.split0, + ) + .0, + ::eip712_data_word( + &self.split1, + ) + .0, + ::eip712_data_word( + &self.split2, + ) + .0, + ::eip712_data_word( + &self.split3, + ) + .0, + ::eip712_data_word( + &self.split4, + ) + .0, + ::eip712_data_word( + &self.zeta, + ) + .0, + ::eip712_data_word( + &self.zetaOmega, + ) .0, ::eip712_data_word( - &self.wireEval0, - ) - .0, + &self.wireEval0, + ) + .0, ::eip712_data_word( - &self.wireEval1, - ) - .0, + &self.wireEval1, + ) + .0, ::eip712_data_word( - &self.wireEval2, - ) - .0, + &self.wireEval2, + ) + .0, ::eip712_data_word( - &self.wireEval3, - ) - .0, + &self.wireEval3, + ) + .0, ::eip712_data_word( - &self.wireEval4, - ) - .0, + &self.wireEval4, + ) + .0, ::eip712_data_word( - &self.sigmaEval0, - ) - .0, + &self.sigmaEval0, + ) + .0, ::eip712_data_word( - &self.sigmaEval1, - ) - .0, + &self.sigmaEval1, + ) + .0, ::eip712_data_word( - &self.sigmaEval2, - ) - .0, + &self.sigmaEval2, + ) + .0, ::eip712_data_word( - &self.sigmaEval3, - ) - .0, + &self.sigmaEval3, + ) + .0, ::eip712_data_word( - &self.prodPermZetaOmegaEval, - ) - .0, + &self.prodPermZetaOmegaEval, + ) + .0, ] - .concat() + .concat() } } #[automatically_derived] @@ -1036,7 +1232,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); ::encode_topic_preimage( &rust.wire0, out, @@ -1082,7 +1280,8 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.zeta, out, + &rust.zeta, + out, ); ::encode_topic_preimage( &rust.zetaOmega, @@ -1130,16 +1329,23 @@ pub mod IPlonkVerifier { ); } #[inline] - fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; /**```solidity - struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } - ```*/ +struct VerifyingKey { uint256 domainSize; uint256 numInputs; BN254.G1Point sigma0; BN254.G1Point sigma1; BN254.G1Point sigma2; BN254.G1Point sigma3; BN254.G1Point sigma4; BN254.G1Point q1; BN254.G1Point q2; BN254.G1Point q3; BN254.G1Point q4; BN254.G1Point qM12; BN254.G1Point qM34; BN254.G1Point qO; BN254.G1Point qC; BN254.G1Point qH1; BN254.G1Point qH2; BN254.G1Point qH3; BN254.G1Point qH4; BN254.G1Point qEcc; bytes32 g2LSB; bytes32 g2MSB; } +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct VerifyingKey { @@ -1248,11 +1454,13 @@ pub mod IPlonkVerifier { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -1361,50 +1569,64 @@ pub mod IPlonkVerifier { if let Some(size) = ::ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encoded_size(&tuple) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encoded_size(&tuple) } #[inline] fn stv_eip712_data_word(&self) -> alloy_sol_types::Word { ::eip712_hash_struct(self) } #[inline] - fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec) { - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_encode_packed_to( - &tuple, out, - ) + fn stv_abi_encode_packed_to( + &self, + out: &mut alloy_sol_types::private::Vec, + ) { + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out) } #[inline] fn stv_abi_packed_encoded_size(&self) -> usize { if let Some(size) = ::PACKED_ENCODED_SIZE { return size; } - let tuple = - as ::core::convert::From>::from(self.clone()); - as alloy_sol_types::SolType>::abi_packed_encoded_size( - &tuple, - ) + let tuple = as ::core::convert::From>::from(self.clone()); + as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple) } } #[automatically_derived] impl alloy_sol_types::SolType for VerifyingKey { type RustType = Self; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SOL_NAME: &'static str = ::NAME; - const ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::ENCODED_SIZE; - const PACKED_ENCODED_SIZE: Option = - as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; + const ENCODED_SIZE: Option = as alloy_sol_types::SolType>::ENCODED_SIZE; + const PACKED_ENCODED_SIZE: Option = as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE; #[inline] fn valid_token(token: &Self::Token<'_>) -> bool { as alloy_sol_types::SolType>::valid_token(token) } #[inline] fn detokenize(token: Self::Token<'_>) -> Self::RustType { - let tuple = as alloy_sol_types::SolType>::detokenize(token); + let tuple = as alloy_sol_types::SolType>::detokenize(token); >>::from(tuple) } } @@ -1418,64 +1640,154 @@ pub mod IPlonkVerifier { ) } #[inline] - fn eip712_components( - ) -> alloy_sol_types::private::Vec> - { + fn eip712_components() -> alloy_sol_types::private::Vec< + alloy_sol_types::private::Cow<'static, str>, + > { let mut components = alloy_sol_types::private::Vec::with_capacity(18); - components.push(::eip712_root_type()); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .extend( + ::eip712_components(), + ); components - .extend(::eip712_components()); - components.push(::eip712_root_type()); + .push( + ::eip712_root_type(), + ); components - .extend(::eip712_components()); + .extend( + ::eip712_components(), + ); + components + .push( + ::eip712_root_type(), + ); + components + .extend( + ::eip712_components(), + ); components } #[inline] @@ -1654,7 +1966,9 @@ pub mod IPlonkVerifier { rust: &Self::RustType, out: &mut alloy_sol_types::private::Vec, ) { - out.reserve(::topic_preimage_length(rust)); + out.reserve( + ::topic_preimage_length(rust), + ); as alloy_sol_types::EventTopic>::encode_topic_preimage( @@ -1688,43 +2002,56 @@ pub mod IPlonkVerifier { out, ); ::encode_topic_preimage( - &rust.q1, out, + &rust.q1, + out, ); ::encode_topic_preimage( - &rust.q2, out, + &rust.q2, + out, ); ::encode_topic_preimage( - &rust.q3, out, + &rust.q3, + out, ); ::encode_topic_preimage( - &rust.q4, out, + &rust.q4, + out, ); ::encode_topic_preimage( - &rust.qM12, out, + &rust.qM12, + out, ); ::encode_topic_preimage( - &rust.qM34, out, + &rust.qM34, + out, ); ::encode_topic_preimage( - &rust.qO, out, + &rust.qO, + out, ); ::encode_topic_preimage( - &rust.qC, out, + &rust.qC, + out, ); ::encode_topic_preimage( - &rust.qH1, out, + &rust.qH1, + out, ); ::encode_topic_preimage( - &rust.qH2, out, + &rust.qH2, + out, ); ::encode_topic_preimage( - &rust.qH3, out, + &rust.qH3, + out, ); ::encode_topic_preimage( - &rust.qH4, out, + &rust.qH4, + out, ); ::encode_topic_preimage( - &rust.qEcc, out, + &rust.qEcc, + out, ); alloy_sol_types::abi::token::WordToken { + fn encode_topic( + rust: &Self::RustType, + ) -> alloy_sol_types::abi::token::WordToken { let mut out = alloy_sol_types::private::Vec::new(); - ::encode_topic_preimage(rust, &mut out); - alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out)) + ::encode_topic_preimage( + rust, + &mut out, + ); + alloy_sol_types::abi::token::WordToken( + alloy_sol_types::private::keccak256(out), + ) } } }; use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -1764,15 +2098,15 @@ pub mod IPlonkVerifier { } /**A [`IPlonkVerifier`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`IPlonkVerifier`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`IPlonkVerifier`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct IPlonkVerifierInstance { address: alloy_sol_types::private::Address, @@ -1783,24 +2117,24 @@ pub mod IPlonkVerifier { impl ::core::fmt::Debug for IPlonkVerifierInstance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("IPlonkVerifierInstance") - .field(&self.address) - .finish() + f.debug_tuple("IPlonkVerifierInstance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /**Creates a new wrapper around an on-chain [`IPlonkVerifier`](self) contract instance. - See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ +See the [wrapper's documentation](`IPlonkVerifierInstance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -1842,11 +2176,10 @@ pub mod IPlonkVerifier { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -1861,11 +2194,10 @@ pub mod IPlonkVerifier { /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > IPlonkVerifierInstance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > IPlonkVerifierInstance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. @@ -2625,9 +2957,8 @@ interface PlonkVerifier2 { clippy::empty_structs_with_brackets )] pub mod PlonkVerifier2 { - use alloy::sol_types as alloy_sol_types; - use super::*; + use alloy::sol_types as alloy_sol_types; /// The creation / init bytecode of the contract. /// /// ```text @@ -2649,9 +2980,9 @@ pub mod PlonkVerifier2 { b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10a\0JW_5`\xE0\x1C\x80c\x1Dq.'\x14a\0NW\x80c\xCESzw\x14a\0\x88W\x80c\xDFnl\xB4\x14a\0\xABW[_\x80\xFD[a\0u\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\x81V[`@Q\x90\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\x9Ba\0\x966`\x04a#\xEDV[a\0\xBFV[`@Q\x90\x15\x15\x81R` \x01a\0\x7FV[a\0u_\x80Q` a%\xF4\x839\x81Q\x91R\x81V[_a\0\xC9\x82a\x10\x12V[a\0\xD9\x83_[` \x02\x01Qa\x11MV[a\0\xE4\x83`\x01a\0\xCFV[a\0\xEF\x83`\x02a\0\xCFV[a\0\xFA\x83`\x03a\0\xCFV[a\x01\x05\x83`\x04a\0\xCFV[a\x01\x10\x83`\x05a\0\xCFV[a\x01\x1B\x83`\x06a\0\xCFV[_a\x01'\x85\x85\x85a\x11\xAFV[\x90P_a\x016\x86_\x01Qa\x17\xB8V[\x90P_a\x01H\x82\x84`\xA0\x01Q\x88a\x1B\x96V[\x90P_a\x01V\x84\x87\x84a\x1B\xF3V[\x90Pa\x025V[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x0C`$\x82\x01Rkerror verify`\xA0\x1B`D\x82\x01R`d\x81\xFD[`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\r`$\x82\x01Rlerror pairing`\x98\x1B`D\x82\x01R`d\x81\xFD[`@Q\x81Q\x81R` \x82\x01Q` \x82\x01R\x82`@\x82\x01R`@_``\x83`\x07Z\xFA\x90P\x80a\x01\xF6Wa\x01\xF6a\x01]V[PPPV[`@\x80Q\x82Q\x81R` \x80\x84\x01Q\x81\x83\x01R_Q\x82\x84\x01RQ``\x82\x01R\x90\x82`\x80\x83`\x06Z\xFA\x90P\x80a\x021Wa\x021a\x01]V[PPV[`@Q`\xC0\x81\x01\x7F&\x0E\x01\xB2Q\xF6\xF1\xC7\xE7\xFFNX\x07\x91\xDE\xE8\xEAQ\xD8z5\x8E\x03\x8BN\xFE0\xFA\xC0\x93\x83\xC1`@\x83\x01R\x7F\x01\x18\xC4\xD5\xB87\xBC\xC2\xBC\x89\xB5\xB3\x98\xB5\x97N\x9FYD\x07;2\x07\x8B~#\x1F\xEC\x93\x88\x83\xB0``\x83\x01R\x7F\x04\xFCci\xF7\x11\x0F\xE3\xD2QV\xC1\xBB\x9Ar\x85\x9C\xF2\xA0FA\xF9\x9B\xA4\xEEA<\x80\xDAj_\xE4`\x80\x83\x01R\x7F\"\xFE\xBD\xA3\xC0\xC0c*VG[B\x14\xE5a^\x11\xE6\xDD?\x96\xE6\xCE\xA2\x85J\x87\xD4\xDA\xCC^U`\xA0\x83\x01R\x7F\x19\x8E\x93\x93\x92\rH:r`\xBF\xB71\xFB]%\xF1\xAAI35\xA9\xE7\x12\x97\xE4\x85\xB7\xAE\xF3\x12\xC2a\x01\0\x83\x01R\x7F\x18\0\xDE\xEF\x12\x1F\x1EvBj\0f^\\DygC\"\xD4\xF7^\xDA\xDDF\xDE\xBD\\\xD9\x92\xF6\xEDa\x01 \x83\x01R\x7F\t\x06\x89\xD0X_\xF0u\xEC\x9E\x99\xADi\x0C3\x95\xBCK13p\xB3\x8E\xF3U\xAC\xDA\xDC\xD1\"\x97[a\x01@\x83\x01R\x7F\x12\xC8^\xA5\xDB\x8Cm\xEBJ\xABq\x80\x8D\xCB@\x8F\xE3\xD1\xE7i\x0CC\xD3{L\xE6\xCC\x01f\xFA}\xAAa\x01`\x83\x01Ra\x01\x80\x82\x01`@R_\x80_\x80`\x80\x8A\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R` \x8A\x01Q` \x8D\x01Q\t\x93P\x8AQ_\x80Q` a%\xF4\x839\x81Q\x91R`\xA0\x8D\x01Q``\x8E\x01Q\t\x93P_\x80Q` a%\xF4\x839\x81Q\x91Ra\x01\xA0\x8F\x01Q\x85\x08\x92P_\x80Q` a%\xF4\x839\x81Q\x91R\x82\x84\x08\x92P_\x80Q` a%\xF4\x839\x81Q\x91R\x81\x84\t\x90P_\x80Q` a%\xF4\x839\x81Q\x91R\x7F/\x8D\xD1\xF1\xA7X\x83\x85a\x01\xC6V[a\x0FG\x85a\x01\xFBV[`@\x80Q\x80\x82\x01\x90\x91R\x93P`\x01\x84R`\x02` \x85\x01Ra\x0Fw\x81_\x80Q` a%\xF4\x839\x81Q\x91R\x03\x85a\x01\xC6V[Pa\x0F\x81\x84a\x01\xFBV[a\x0F\xB0\x84` \x01\x80Q\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\x03\x90RV[PPPa\x01`\x88\x01Q\x80Q\x83R` \x90\x81\x01Q\x90\x83\x01R`\xE0\x86\x01Qa\x01\x80\x89\x01Q\x90a\x0F\xDD\x81\x83a\x01\xC6V[PPPa\x0F\xE9\x81a\x01\xFBV[` _a\x01\x80\x83`\x08Z\xFA\x90P\x80a\x10\x03Wa\x10\x03a\x01\x91V[PP_Q\x97\x96PPPPPPPV[\x80Qa\x10\x1D\x90a\x1D\xA8V[a\x10*\x81` \x01Qa\x1D\xA8V[a\x107\x81`@\x01Qa\x1D\xA8V[a\x10D\x81``\x01Qa\x1D\xA8V[a\x10Q\x81`\x80\x01Qa\x1D\xA8V[a\x10^\x81`\xA0\x01Qa\x1D\xA8V[a\x10k\x81`\xC0\x01Qa\x1D\xA8V[a\x10x\x81`\xE0\x01Qa\x1D\xA8V[a\x10\x86\x81a\x01\0\x01Qa\x1D\xA8V[a\x10\x94\x81a\x01 \x01Qa\x1D\xA8V[a\x10\xA2\x81a\x01@\x01Qa\x1D\xA8V[a\x10\xB0\x81a\x01`\x01Qa\x1D\xA8V[a\x10\xBE\x81a\x01\x80\x01Qa\x1D\xA8V[a\x10\xCC\x81a\x01\xA0\x01Qa\x11MV[a\x10\xDA\x81a\x01\xC0\x01Qa\x11MV[a\x10\xE8\x81a\x01\xE0\x01Qa\x11MV[a\x10\xF6\x81a\x02\0\x01Qa\x11MV[a\x11\x04\x81a\x02 \x01Qa\x11MV[a\x11\x12\x81a\x02@\x01Qa\x11MV[a\x11 \x81a\x02`\x01Qa\x11MV[a\x11.\x81a\x02\x80\x01Qa\x11MV[a\x11<\x81a\x02\xA0\x01Qa\x11MV[a\x11J\x81a\x02\xC0\x01Qa\x11MV[PV[_\x80Q` a%\xF4\x839\x81Q\x91R\x81\x10\x80a\x021W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1B`$\x82\x01R\x7FBn254: invalid scalar field\0\0\0\0\0`D\x82\x01R`d\x01[`@Q\x80\x91\x03\x90\xFD[a\x11\xEF`@Q\x80a\x01\0\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81R` \x01_\x81RP\x90V[`@Q` \x81\x01_\x81R`\xFE`\xE0\x1B\x81R\x85Q`\xC0\x1B`\x04\x82\x01R` \x86\x01Q`\xC0\x1B`\x0C\x82\x01Ra\x02\x80\x86\x01Q` \x82\x01Ra\x02\xA0\x86\x01Q`@\x82\x01R`\x01``\x82\x01R\x7F/\x8D\xD1\xF1\xA7X\xA8\x01f\x9Cd\x01q \xE1t \xAA\xE6\xAD\xAA\x01\xC2a|n\x85\x81R` \x01\x7F\x12YzV\xC2\xE48b\x0B\x90A\xB9\x89\x92\xAE\rNp[x\0W\xBFwf\xA2v|\xEC\xE1n\x1D\x81R` \x01\x7F\x02\xD9A\x17\xCD\x17\xBC\xF1)\x0F\xD6|\x01\x15]\xD4\x08\x07\x85}\xFFJZ\x0BM\xC6{\xEF\xA8\xAA4\xFD\x81RP\x81RP\x90P\x91\x90PV[\x81b\x10\0\0\x03a\x1A?W`@Q\x80``\x01`@R\x80`\x14\x81R` \x01\x7F0dKl\x9CJr\x16\x9EM\xAA1}%\xF0E\x12\xAE\x15\xC5;4\xE8\xF5\xAC\xD8\xE1U\xD0\xA6\xC1\x01\x81R` \x01`@Q\x80`\xE0\x01`@R\x80`\x01\x81R` \x01\x7F&\x12]\xA1\n\x0E\xD0c'P\x8A\xBA\x06\xD1\xE3\x03\xACaf2\xDB\xED4\x9FSB-\xA9S3xW\x81R` \x01\x7F\"`\xE7$\x84K\xCARQ\x82\x93S\x96\x8EI\x150RXA\x83WG:\\\x1DY\x7Fa?l\xBD\x81R` \x01\x7F \x87\xEA,\xD6d'\x86\x08\xFB\x0E\xBD\xB8 \x90\x7FY\x85\x02\xC8\x1Bf\x90\xC1\x85\xE2\xBF\x15\xCB\x93_B\x81R` \x01\x7F\x19\xDD\xBC\xAF:\x8DF\xC1\\\x01v\xFB\xB5\xB9^M\xC5p\x88\xFF\x13\xF4\xD1\xBD\x84\xC6\xBF\xA5}\xCD\xC0\xE0\x81R` \x01\x7F\x05\xA2\xC8\\\xFCY\x17\x89`\\\xAE\x81\x8E7\xDDAa\xEE\xF9\xAAfk\xECo\xE4(\x8D\t\xE6\xD24\x18\x81R` \x01\x7F\x11\xF7\x0ESc%\x8F\xF4\xF0\xD7\x16\xA6S\xE1\xDCA\xF1\xC6D\x84\xD7\xF4\xB6\xE2\x19\xD67v\x14\xA3\x90\\\x81RP\x81RP\x90P\x91\x90PV[\x81` \x03a\x1B}W`@Q\x80``\x01`@R\x80`\x05\x81R` \x01\x7F.\xE1+\xFFJ(\x13(j\x8D\xC3\x88\xCDuM\x9A>\xF2I\x065\xEB\xA5\x0C\xB9\xC2\xE5\xE7P\x80\0\x01\x81R` \x01`@Q\x80`\xE0\x01`@R\x80`\x01\x81R` \x01\x7F\t\xC52\xC60k\x93\xD2\x96x \rG\xC0\xB2\xA9\x9C\x18\xD5\x1B\x83\x8E\xEB\x1D>\xEDLS;\xB5\x12\xD0\x81R` \x01\x7F!\x08,\xA2\x16\xCB\xBFN\x1CnOE\x94\xDDP\x8C\x99m\xFB\xE1\x17N\xFB\x98\xB1\x15\t\xC6\xE3\x06F\x0B\x81R` \x01\x7F\x12w\xAEd\x15\xF0\xEF\x18\xF2\xBA_\xB1b\xC3\x9E\xB71\x1F8n-&\xD6D\x01\xF4\xA2]\xA7|%;\x81R` \x01\x7F+3}\xE1\xC8\xC1O\"\xEC\x9B\x9E/\x96\xAF\xEF6Rbsf\xF8\x17\n\n\x94\x8D\xADJ\xC1\xBD^\x80\x81R` \x01\x7F/\xBDM\xD2\x97k\xE5]\x1A\x16:\xA9\x82\x0F\xB8\x8D\xFA\xC5\xDD\xCEw\xE1\x87.\x90c '2z^\xBE\x81R` \x01\x7F\x10z\xABI\xE6Zg\xF9\xDA\x9C\xD2\xAB\xF7\x8B\xE3\x8B\xD9\xDC\x1D]\xB3\x9F\x81\xDE6\xBC\xFA[K\x03\x90C\x81RP\x81RP\x90P\x91\x90PV[`@Qc\xE2\xEF\t\xE5`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x1B\xB7`@Q\x80``\x01`@R\x80_\x81R` \x01_\x81R` \x01_\x81RP\x90V[a\x1B\xC1\x84\x84a\x1EQV[\x80\x82Ra\x1B\xD1\x90\x85\x90\x85\x90a\x1E\xA2V[` \x82\x01R\x80Qa\x1B\xE7\x90\x85\x90\x84\x90\x86\x90a\x1F\x13V[`@\x82\x01R\x93\x92PPPV[` \x81\x01Q`@\x82\x01Q``\x85\x01Q`\x80\x86\x01Qa\x01\xA0\x86\x01Qa\x02@\x87\x01Q_\x95\x94\x93`\x01\x93\x90\x92\x90\x91_\x80Q` a%\xF4\x839\x81Q\x91R\x80\x80\x83\x87\t_\x80Q` a%\xF4\x839\x81Q\x91R\x86\x86\x08\x08\x86\t\x94PPPa\x01\xC0\x88\x01Qa\x02`\x89\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x80_\x80Q` a%\xF4\x839\x81Q\x91R\x83\x87\t_\x80Q` a%\xF4\x839\x81Q\x91R\x86\x86\x08\x08\x86\t\x94PPPa\x01\xE0\x88\x01Qa\x02\x80\x89\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x80_\x80Q` a%\xF4\x839\x81Q\x91R\x83\x87\t_\x80Q` a%\xF4\x839\x81Q\x91R\x86\x86\x08\x08\x86\t\x94PPPa\x02\0\x88\x01Qa\x02\xA0\x89\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x80_\x80Q` a%\xF4\x839\x81Q\x91R\x83\x87\t_\x80Q` a%\xF4\x839\x81Q\x91R\x86\x86\x08\x08\x86\t\x94PPPa\x02 \x88\x01Q\x91Pa\x02\xC0\x88\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x80\x82_\x80Q` a%\xF4\x839\x81Q\x91R\x85\x87\x08\t\x85\t\x93PPPP\x86Q` \x88\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x80\x86\x83\t_\x80Q` a%\xF4\x839\x81Q\x91R\x03\x85\x08\x95PP_\x80Q` a%\xF4\x839\x81Q\x91R\x80\x83\x83\t_\x80Q` a%\xF4\x839\x81Q\x91R\x03\x86\x08\x98\x97PPPPPPPPV[\x80Q` \x82\x01Q_\x91\x7F0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X]\x97\x81j\x91hq\xCA\x8D< \x8C\x16\xD8|\xFDG\x91\x15\x90\x15\x16\x15a\x1D\xE1WPPPV[\x82Q` \x84\x01Q\x82`\x03\x84\x85\x85\x86\t\x85\t\x08\x83\x82\x83\t\x14\x83\x82\x10\x84\x84\x10\x16\x16\x93PPP\x81a\x01\xF6W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x17`$\x82\x01R\x7FBn254: invalid G1 point\0\0\0\0\0\0\0\0\0`D\x82\x01R`d\x01a\x11\xA6V[\x81Q_\x90_\x80Q` a%\xF4\x839\x81Q\x91R\x90\x83\x80\x15a\x1E\x92W\x84\x93P_[\x82\x81\x10\x15a\x1E\x86W\x83\x85\x86\t\x94P`\x01\x01a\x1EpV[P`\x01\x84\x03\x93Pa\x1E\x99V[`\x01\x83\x03\x93P[PPP\x92\x91PPV[_\x82`\x01\x03a\x1E\xB3WP`\x01a\x1F\x0CV[\x81_\x03a\x1E\xC1WP_a\x1F\x0CV[` \x84\x01Q_\x80Q` a%\xF4\x839\x81Q\x91R\x90_\x90\x82\x81\x86\t\x90P\x85\x80\x15a\x1E\xEFW`\x01\x87\x03\x92Pa\x1E\xF6V[`\x01\x84\x03\x92P[Pa\x1F\0\x82a cV[\x91P\x82\x82\x82\t\x93PPPP[\x93\x92PPPV[__\x80Q` a%\xF4\x839\x81Q\x91R\x82\x82\x03a\x1F\x8CW`\x01_[`\x07\x81\x10\x15a\x1F\x81W\x81\x86\x03a\x1F^W\x86\x81`\x07\x81\x10a\x1FOWa\x1FOa%\xCBV[` \x02\x01Q\x93PPPPa [V[\x82\x80a\x1FlWa\x1Fla%\xDFV[`@\x89\x01Q` \x01Q\x83\t\x91P`\x01\x01a\x1F-V[P_\x92PPPa [V[a\x1F\x94a!(V[`@\x87\x01Q`\x01`\xC0\x83\x81\x01\x82\x81R\x92\x01\x90\x80[`\x07\x81\x10\x15a\x1F\xD5W` \x84\x03\x93P\x85\x86\x8A\x85Q\x89\x03\x08\x83\t\x80\x85R`\x1F\x19\x90\x93\x01\x92\x91P`\x01\x01a\x1F\xA8V[PPPP_\x80_\x90P`\x01\x83\x89`@\x8C\x01Q_[`\x07\x81\x10\x15a )W\x88\x82Q\x8A\x85Q\x8C\x88Q\x8A\t\t\t\x89\x81\x88\x08\x96PP\x88\x89\x8D\x84Q\x8C\x03\x08\x86\t\x94P` \x93\x84\x01\x93\x92\x83\x01\x92\x91\x90\x91\x01\x90`\x01\x01a\x1F\xE9V[PPPP\x80\x92PP_a ;\x83a cV[\x90P` \x8A\x01Q\x85\x81\x89\t\x96PP\x84\x81\x87\t\x95P\x84\x82\x87\t\x95PPPPPP[\x94\x93PPPPV[_\x80__\x80Q` a%\xF4\x839\x81Q\x91R\x90P`@Q` \x81R` \x80\x82\x01R` `@\x82\x01R\x84``\x82\x01R`\x02\x82\x03`\x80\x82\x01R\x81`\xA0\x82\x01R` _`\xC0\x83`\x05Z\xFA\x92PP_Q\x92P\x81a \xFDW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`\x1D`$\x82\x01R\x7FBn254: pow precompile failed!\0\0\0`D\x82\x01R`d\x01a\x11\xA6V[PP\x91\x90PV[`@Q\x80``\x01`@R\x80_\x81R` \x01_\x81R` \x01a!#a!(V[\x90R\x90V[`@Q\x80`\xE0\x01`@R\x80`\x07\x90` \x82\x02\x806\x837P\x91\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[`@Qa\x02\xE0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a!~Wa!~a!FV[`@R\x90V[`@Qa\x02\xC0\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a!~Wa!~a!FV[_`@\x82\x84\x03\x12\x15a!\xB8W_\x80\xFD[`@Q`@\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a!\xDBWa!\xDBa!FV[`@R\x825\x81R` \x92\x83\x015\x92\x81\x01\x92\x90\x92RP\x91\x90PV[_\x82`\x1F\x83\x01\x12a\"\x04W_\x80\xFD[`@Q`\xE0\x81\x01\x81\x81\x10g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x82\x11\x17\x15a\"'Wa\"'a!FV[`@R\x80`\xE0\x84\x01\x85\x81\x11\x15a\";W_\x80\xFD[\x84[\x81\x81\x10\x15a\"UW\x805\x83R` \x92\x83\x01\x92\x01a\"=V[P\x91\x95\x94PPPPPV[_a\x04\x80\x82\x84\x03\x12\x15a\"qW_\x80\xFD[a\"ya!ZV[\x90Pa\"\x85\x83\x83a!\xA8V[\x81Ra\"\x94\x83`@\x84\x01a!\xA8V[` \x82\x01Ra\"\xA6\x83`\x80\x84\x01a!\xA8V[`@\x82\x01Ra\"\xB8\x83`\xC0\x84\x01a!\xA8V[``\x82\x01Ra\x01\0a\"\xCC\x84\x82\x85\x01a!\xA8V[`\x80\x83\x01Ra\x01@a\"\xE0\x85\x82\x86\x01a!\xA8V[`\xA0\x84\x01Ra\x01\x80a\"\xF4\x86\x82\x87\x01a!\xA8V[`\xC0\x85\x01Ra\x01\xC0a#\x08\x87\x82\x88\x01a!\xA8V[`\xE0\x86\x01Ra\x02\0a#\x1C\x88\x82\x89\x01a!\xA8V[\x85\x87\x01Ra\x02@\x94Pa#1\x88\x86\x89\x01a!\xA8V[a\x01 \x87\x01Ra\x02\x80a#F\x89\x82\x8A\x01a!\xA8V[\x85\x88\x01Ra\x02\xC0\x94Pa#[\x89\x86\x8A\x01a!\xA8V[a\x01`\x88\x01Ra#o\x89a\x03\0\x8A\x01a!\xA8V[\x84\x88\x01Ra\x03@\x88\x015a\x01\xA0\x88\x01Ra\x03`\x88\x015\x83\x88\x01Ra\x03\x80\x88\x015a\x01\xE0\x88\x01Ra\x03\xA0\x88\x015\x82\x88\x01Ra\x03\xC0\x88\x015a\x02 \x88\x01Ra\x03\xE0\x88\x015\x86\x88\x01Ra\x04\0\x88\x015a\x02`\x88\x01Ra\x04 \x88\x015\x81\x88\x01RPPPPa\x04@\x84\x015a\x02\xA0\x84\x01Ra\x04`\x84\x015\x81\x84\x01RPP\x92\x91PPV[_\x80_\x83\x85\x03a\n`\x81\x12\x15a$\x01W_\x80\xFD[a\x05\0\x80\x82\x12\x15a$\x10W_\x80\xFD[a$\x18a!\x84V[\x91P\x855\x82R` \x86\x015` \x83\x01Ra$5\x87`@\x88\x01a!\xA8V[`@\x83\x01Ra$G\x87`\x80\x88\x01a!\xA8V[``\x83\x01Ra$Y\x87`\xC0\x88\x01a!\xA8V[`\x80\x83\x01Ra\x01\0a$m\x88\x82\x89\x01a!\xA8V[`\xA0\x84\x01Ra\x01@a$\x81\x89\x82\x8A\x01a!\xA8V[`\xC0\x85\x01Ra\x01\x80a$\x95\x8A\x82\x8B\x01a!\xA8V[`\xE0\x86\x01Ra\x01\xC0a$\xA9\x8B\x82\x8C\x01a!\xA8V[\x84\x87\x01Ra\x02\0\x93Pa$\xBE\x8B\x85\x8C\x01a!\xA8V[a\x01 \x87\x01Ra\x02@a$\xD3\x8C\x82\x8D\x01a!\xA8V[\x84\x88\x01Ra\x02\x80\x93Pa$\xE8\x8C\x85\x8D\x01a!\xA8V[a\x01`\x88\x01Ra$\xFC\x8Ca\x02\xC0\x8D\x01a!\xA8V[\x83\x88\x01Ra%\x0E\x8Ca\x03\0\x8D\x01a!\xA8V[a\x01\xA0\x88\x01Ra%\"\x8Ca\x03@\x8D\x01a!\xA8V[\x82\x88\x01Ra%4\x8Ca\x03\x80\x8D\x01a!\xA8V[a\x01\xE0\x88\x01Ra%H\x8Ca\x03\xC0\x8D\x01a!\xA8V[\x85\x88\x01Ra%Z\x8Ca\x04\0\x8D\x01a!\xA8V[a\x02 \x88\x01Ra%n\x8Ca\x04@\x8D\x01a!\xA8V[\x81\x88\x01RPPPa%\x83\x89a\x04\x80\x8A\x01a!\xA8V[a\x02`\x85\x01Ra\x04\xC0\x88\x015\x81\x85\x01RPPa\x04\xE0\x86\x015a\x02\xA0\x83\x01R\x81\x94Pa%\xB0\x87\x82\x88\x01a!\xF5V[\x93PPPa%\xC2\x85a\x05\xE0\x86\x01a\"`V[\x90P\x92P\x92P\x92V[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`\x12`\x04R`$_\xFD\xFE0dNr\xE11\xA0)\xB8PE\xB6\x81\x81X](3\xE8Hy\xB9p\x91C\xE1\xF5\x93\xF0\0\0\x01\xA1dsolcC\0\x08\x17\0\n", ); /**Custom error with signature `UnsupportedDegree()` and selector `0xe2ef09e5`. - ```solidity - error UnsupportedDegree(); - ```*/ +```solidity +error UnsupportedDegree(); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct UnsupportedDegree {} @@ -2669,11 +3000,13 @@ pub mod PlonkVerifier2 { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2693,7 +3026,9 @@ pub mod PlonkVerifier2 { #[automatically_derived] impl alloy_sol_types::SolError for UnsupportedDegree { type Parameters<'a> = UnderlyingSolTuple<'a>; - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "UnsupportedDegree()"; const SELECTOR: [u8; 4] = [226u8, 239u8, 9u8, 229u8]; #[inline] @@ -2709,9 +3044,9 @@ pub mod PlonkVerifier2 { } }; /**Function with signature `P_MOD()` and selector `0x1d712e27`. - ```solidity - function P_MOD() external view returns (uint256); - ```*/ +```solidity +function P_MOD() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct P_MODCall {} @@ -2737,11 +3072,13 @@ pub mod PlonkVerifier2 { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2763,14 +3100,18 @@ pub mod PlonkVerifier2 { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2791,10 +3132,14 @@ pub mod PlonkVerifier2 { #[automatically_derived] impl alloy_sol_types::SolCall for P_MODCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = P_MODReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "P_MOD()"; const SELECTOR: [u8; 4] = [29u8, 113u8, 46u8, 39u8]; #[inline] @@ -2812,17 +3157,17 @@ pub mod PlonkVerifier2 { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `R_MOD()` and selector `0xdf6e6cb4`. - ```solidity - function R_MOD() external view returns (uint256); - ```*/ +```solidity +function R_MOD() external view returns (uint256); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct R_MODCall {} @@ -2848,11 +3193,13 @@ pub mod PlonkVerifier2 { type UnderlyingRustTuple<'a> = (); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2874,14 +3221,18 @@ pub mod PlonkVerifier2 { #[doc(hidden)] type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); #[doc(hidden)] - type UnderlyingRustTuple<'a> = (alloy::sol_types::private::primitives::aliases::U256,); + type UnderlyingRustTuple<'a> = ( + alloy::sol_types::private::primitives::aliases::U256, + ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -2902,10 +3253,14 @@ pub mod PlonkVerifier2 { #[automatically_derived] impl alloy_sol_types::SolCall for R_MODCall { type Parameters<'a> = (); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = R_MODReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "R_MOD()"; const SELECTOR: [u8; 4] = [223u8, 110u8, 108u8, 180u8]; #[inline] @@ -2923,17 +3278,17 @@ pub mod PlonkVerifier2 { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; /**Function with signature `verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[7],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))` and selector `0x77ae3f07`. - ```solidity - function verify(IPlonkVerifier.VerifyingKey memory vk, uint256[7] memory publicInput, IPlonkVerifier.PlonkProof memory proof) external view returns (bool success); - ```*/ +```solidity +function verify(IPlonkVerifier.VerifyingKey memory vk, uint256[7] memory publicInput, IPlonkVerifier.PlonkProof memory proof) external view returns (bool success); +```*/ #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)] #[derive(Clone)] pub struct verifyCall { @@ -2977,11 +3332,13 @@ pub mod PlonkVerifier2 { ); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3010,11 +3367,13 @@ pub mod PlonkVerifier2 { type UnderlyingRustTuple<'a> = (bool,); #[cfg(test)] #[allow(dead_code, unreachable_patterns)] - fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq) { + fn _type_assertion( + _t: alloy_sol_types::private::AssertTypeEq, + ) { match _t { alloy_sol_types::private::AssertTypeEq::< ::RustType, - >(_) => {}, + >(_) => {} } } #[automatically_derived] @@ -3042,10 +3401,14 @@ pub mod PlonkVerifier2 { >, IPlonkVerifier::PlonkProof, ); - type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; + type Token<'a> = as alloy_sol_types::SolType>::Token<'a>; type Return = verifyReturn; type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,); - type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; + type ReturnToken<'a> = as alloy_sol_types::SolType>::Token<'a>; const SIGNATURE: &'static str = "verify((uint256,uint256,(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),bytes32,bytes32),uint256[7],((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256,uint256),uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256))"; const SELECTOR: [u8; 4] = [119u8, 174u8, 63u8, 7u8]; #[inline] @@ -3057,12 +3420,16 @@ pub mod PlonkVerifier2 { #[inline] fn tokenize(&self) -> Self::Token<'_> { ( - ::tokenize(&self.vk), + ::tokenize( + &self.vk, + ), , 7usize, > as alloy_sol_types::SolType>::tokenize(&self.publicInput), - ::tokenize(&self.proof), + ::tokenize( + &self.proof, + ), ) } #[inline] @@ -3070,10 +3437,10 @@ pub mod PlonkVerifier2 { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - as alloy_sol_types::SolType>::abi_decode_sequence( - data, validate, - ) - .map(Into::into) + as alloy_sol_types::SolType>::abi_decode_sequence(data, validate) + .map(Into::into) } } }; @@ -3131,14 +3498,16 @@ pub mod PlonkVerifier2 { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[ + ) -> alloy_sol_types::Result] = &[ { fn P_MOD( data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PlonkVerifier2Calls::P_MOD) } P_MOD @@ -3148,7 +3517,10 @@ pub mod PlonkVerifier2 { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PlonkVerifier2Calls::verify) } verify @@ -3158,17 +3530,22 @@ pub mod PlonkVerifier2 { data: &[u8], validate: bool, ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) + ::abi_decode_raw( + data, + validate, + ) .map(PlonkVerifier2Calls::R_MOD) } R_MOD }, ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3177,13 +3554,13 @@ pub mod PlonkVerifier2 { match self { Self::P_MOD(inner) => { ::abi_encoded_size(inner) - }, + } Self::R_MOD(inner) => { ::abi_encoded_size(inner) - }, + } Self::verify(inner) => { ::abi_encoded_size(inner) - }, + } } } #[inline] @@ -3191,13 +3568,13 @@ pub mod PlonkVerifier2 { match self { Self::P_MOD(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::R_MOD(inner) => { ::abi_encode_raw(inner, out) - }, + } Self::verify(inner) => { ::abi_encode_raw(inner, out) - }, + } } } } @@ -3226,7 +3603,7 @@ pub mod PlonkVerifier2 { match self { Self::UnsupportedDegree(_) => { ::SELECTOR - }, + } } } #[inline] @@ -3247,22 +3624,28 @@ pub mod PlonkVerifier2 { static DECODE_SHIMS: &[fn( &[u8], bool, - ) - -> alloy_sol_types::Result] = &[{ - fn UnsupportedDegree( - data: &[u8], - validate: bool, - ) -> alloy_sol_types::Result { - ::abi_decode_raw(data, validate) - .map(PlonkVerifier2Errors::UnsupportedDegree) - } - UnsupportedDegree - }]; + ) -> alloy_sol_types::Result] = &[ + { + fn UnsupportedDegree( + data: &[u8], + validate: bool, + ) -> alloy_sol_types::Result { + ::abi_decode_raw( + data, + validate, + ) + .map(PlonkVerifier2Errors::UnsupportedDegree) + } + UnsupportedDegree + }, + ]; let Ok(idx) = Self::SELECTORS.binary_search(&selector) else { - return Err(alloy_sol_types::Error::unknown_selector( - ::NAME, - selector, - )); + return Err( + alloy_sol_types::Error::unknown_selector( + ::NAME, + selector, + ), + ); }; DECODE_SHIMS[idx](data, validate) } @@ -3270,23 +3653,28 @@ pub mod PlonkVerifier2 { fn abi_encoded_size(&self) -> usize { match self { Self::UnsupportedDegree(inner) => { - ::abi_encoded_size(inner) - }, + ::abi_encoded_size( + inner, + ) + } } } #[inline] fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec) { match self { Self::UnsupportedDegree(inner) => { - ::abi_encode_raw(inner, out) - }, + ::abi_encode_raw( + inner, + out, + ) + } } } } use alloy::contract as alloy_contract; /**Creates a new wrapper around an on-chain [`PlonkVerifier2`](self) contract instance. - See the [wrapper's documentation](`PlonkVerifier2Instance`) for more details.*/ +See the [wrapper's documentation](`PlonkVerifier2Instance`) for more details.*/ #[inline] pub const fn new< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3300,9 +3688,9 @@ pub mod PlonkVerifier2 { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub fn deploy< T: alloy_contract::private::Transport + ::core::clone::Clone, @@ -3310,36 +3698,35 @@ pub mod PlonkVerifier2 { N: alloy_contract::private::Network, >( provider: P, - ) -> impl ::core::future::Future>> - { + ) -> impl ::core::future::Future< + Output = alloy_contract::Result>, + > { PlonkVerifier2Instance::::deploy(provider) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder< T: alloy_contract::private::Transport + ::core::clone::Clone, P: alloy_contract::private::Provider, N: alloy_contract::private::Network, - >( - provider: P, - ) -> alloy_contract::RawCallBuilder { + >(provider: P) -> alloy_contract::RawCallBuilder { PlonkVerifier2Instance::::deploy_builder(provider) } /**A [`PlonkVerifier2`](self) instance. - Contains type-safe methods for interacting with an on-chain instance of the - [`PlonkVerifier2`](self) contract located at a given `address`, using a given - provider `P`. +Contains type-safe methods for interacting with an on-chain instance of the +[`PlonkVerifier2`](self) contract located at a given `address`, using a given +provider `P`. - If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) - documentation on how to provide it), the `deploy` and `deploy_builder` methods can - be used to deploy a new instance of the contract. +If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!) +documentation on how to provide it), the `deploy` and `deploy_builder` methods can +be used to deploy a new instance of the contract. - See the [module-level documentation](self) for all the available methods.*/ +See the [module-level documentation](self) for all the available methods.*/ #[derive(Clone)] pub struct PlonkVerifier2Instance { address: alloy_sol_types::private::Address, @@ -3350,24 +3737,24 @@ pub mod PlonkVerifier2 { impl ::core::fmt::Debug for PlonkVerifier2Instance { #[inline] fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result { - f.debug_tuple("PlonkVerifier2Instance") - .field(&self.address) - .finish() + f.debug_tuple("PlonkVerifier2Instance").field(&self.address).finish() } } /// Instantiation and getters/setters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifier2Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifier2Instance { /**Creates a new wrapper around an on-chain [`PlonkVerifier2`](self) contract instance. - See the [wrapper's documentation](`PlonkVerifier2Instance`) for more details.*/ +See the [wrapper's documentation](`PlonkVerifier2Instance`) for more details.*/ #[inline] - pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self { + pub const fn new( + address: alloy_sol_types::private::Address, + provider: P, + ) -> Self { Self { address, provider, @@ -3376,9 +3763,9 @@ pub mod PlonkVerifier2 { } /**Deploys this contract using the given `provider` and constructor arguments, if any. - Returns a new instance of the contract, if the deployment was successful. +Returns a new instance of the contract, if the deployment was successful. - For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ +For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/ #[inline] pub async fn deploy( provider: P, @@ -3388,10 +3775,10 @@ pub mod PlonkVerifier2 { Ok(Self::new(contract_address, call_builder.provider)) } /**Creates a `RawCallBuilder` for deploying this contract using the given `provider` - and constructor arguments, if any. +and constructor arguments, if any. - This is a simple wrapper around creating a `RawCallBuilder` with the data set to - the bytecode concatenated with the constructor's ABI-encoded arguments.*/ +This is a simple wrapper around creating a `RawCallBuilder` with the data set to +the bytecode concatenated with the constructor's ABI-encoded arguments.*/ #[inline] pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder { alloy_contract::RawCallBuilder::new_raw_deploy( @@ -3434,11 +3821,10 @@ pub mod PlonkVerifier2 { /// Function calls. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifier2Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifier2Instance { /// Creates a new call builder using this contract instance's provider and address. /// /// Note that the call can be any function call, not just those defined in this @@ -3464,21 +3850,22 @@ pub mod PlonkVerifier2 { publicInput: [alloy::sol_types::private::primitives::aliases::U256; 7usize], proof: ::RustType, ) -> alloy_contract::SolCallBuilder { - self.call_builder(&verifyCall { - vk, - publicInput, - proof, - }) + self.call_builder( + &verifyCall { + vk, + publicInput, + proof, + }, + ) } } /// Event filters. #[automatically_derived] impl< - T: alloy_contract::private::Transport + ::core::clone::Clone, - P: alloy_contract::private::Provider, - N: alloy_contract::private::Network, - > PlonkVerifier2Instance - { + T: alloy_contract::private::Transport + ::core::clone::Clone, + P: alloy_contract::private::Provider, + N: alloy_contract::private::Network, + > PlonkVerifier2Instance { /// Creates a new event filter using this contract instance's provider and address. /// /// Note that the type can be any event, not just those defined in this contract. From 726378302ec8ce0ab2730a5568c9a64321516761 Mon Sep 17 00:00:00 2001 From: tbro Date: Thu, 13 Mar 2025 08:59:45 -0300 Subject: [PATCH 4/4] Cargo.lock updated once_cell --- Cargo.lock | 474 ++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 401 insertions(+), 73 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2ccdfaa67e..052f2ed5b3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -137,24 +137,45 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f438db4dcc20bd52223b3d5bc279b8394bc2488cf0176b5774950954d5c2c147" dependencies = [ - "alloy-consensus", - "alloy-contract", + "alloy-consensus 0.12.4", + "alloy-contract 0.12.4", "alloy-core", - "alloy-eips", - "alloy-json-rpc", - "alloy-network", - "alloy-provider", + "alloy-eips 0.12.4", + "alloy-json-rpc 0.12.4", + "alloy-network 0.12.4", + "alloy-provider 0.12.4", "alloy-pubsub", - "alloy-rpc-client", - "alloy-rpc-types", - "alloy-serde", - "alloy-signer", - "alloy-signer-local", - "alloy-transport", - "alloy-transport-http", + "alloy-rpc-client 0.12.4", + "alloy-rpc-types 0.12.4", + "alloy-serde 0.12.4", + "alloy-signer 0.12.4", + "alloy-signer-local 0.12.4", + "alloy-transport 0.12.4", + "alloy-transport-http 0.12.4", "alloy-transport-ws", ] +[[package]] +name = "alloy" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-contract 0.12.5", + "alloy-core", + "alloy-eips 0.12.5", + "alloy-genesis", + "alloy-network 0.12.5", + "alloy-provider 0.12.5", + "alloy-rpc-client 0.12.5", + "alloy-rpc-types 0.12.5", + "alloy-serde 0.12.5", + "alloy-signer 0.12.5", + "alloy-signer-local 0.12.5", + "alloy-transport 0.12.5", + "alloy-transport-http 0.12.5", +] + [[package]] name = "alloy-chains" version = "0.1.63" @@ -172,10 +193,32 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1715ed2a977d3ca4b39ffe0fc69f9f5b0e81382b348bdb5172abaa77a10f0b6d" dependencies = [ - "alloy-eips", + "alloy-eips 0.12.4", "alloy-primitives", "alloy-rlp", - "alloy-serde", + "alloy-serde 0.12.4", + "alloy-trie", + "auto_impl", + "c-kzg", + "derive_more 2.0.1", + "either", + "k256", + "once_cell", + "rand 0.8.5", + "serde", + "serde_with", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-consensus" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-eips 0.12.5", + "alloy-primitives", + "alloy-rlp", + "alloy-serde 0.12.5", "alloy-trie", "auto_impl", "c-kzg", @@ -195,11 +238,24 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "660705969af143897d83937d73f53c741c1587f49c27c2cfce594e188fcbc1e4" dependencies = [ - "alloy-consensus", - "alloy-eips", + "alloy-consensus 0.12.4", + "alloy-eips 0.12.4", "alloy-primitives", "alloy-rlp", - "alloy-serde", + "alloy-serde 0.12.4", + "serde", +] + +[[package]] +name = "alloy-consensus-any" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-eips 0.12.5", + "alloy-primitives", + "alloy-rlp", + "alloy-serde 0.12.5", "serde", ] @@ -211,14 +267,34 @@ checksum = "5362637b25ba5282a921ca139a10f188fa34e1248a7c83c907a21de54d36dce1" dependencies = [ "alloy-dyn-abi", "alloy-json-abi", - "alloy-network", - "alloy-network-primitives", + "alloy-network 0.12.4", + "alloy-network-primitives 0.12.4", "alloy-primitives", - "alloy-provider", + "alloy-provider 0.12.4", "alloy-pubsub", - "alloy-rpc-types-eth", + "alloy-rpc-types-eth 0.12.4", + "alloy-sol-types", + "alloy-transport 0.12.4", + "futures", + "futures-util", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-contract" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-dyn-abi", + "alloy-json-abi", + "alloy-network 0.12.5", + "alloy-network-primitives 0.12.5", + "alloy-primitives", + "alloy-provider 0.12.5", + "alloy-rpc-types-eth 0.12.5", "alloy-sol-types", - "alloy-transport", + "alloy-transport 0.12.5", "futures", "futures-util", "thiserror 2.0.12", @@ -233,6 +309,7 @@ dependencies = [ "alloy-dyn-abi", "alloy-json-abi", "alloy-primitives", + "alloy-rlp", "alloy-sol-types", ] @@ -300,7 +377,7 @@ dependencies = [ "alloy-eip7702", "alloy-primitives", "alloy-rlp", - "alloy-serde", + "alloy-serde 0.12.4", "auto_impl", "c-kzg", "derive_more 2.0.1", @@ -310,6 +387,38 @@ dependencies = [ "sha2 0.10.8", ] +[[package]] +name = "alloy-eips" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-eip2124", + "alloy-eip2930", + "alloy-eip7702", + "alloy-primitives", + "alloy-rlp", + "alloy-serde 0.12.5", + "auto_impl", + "c-kzg", + "derive_more 2.0.1", + "either", + "once_cell", + "serde", + "sha2 0.10.8", +] + +[[package]] +name = "alloy-genesis" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-eips 0.12.5", + "alloy-primitives", + "alloy-serde 0.12.5", + "alloy-trie", + "serde", +] + [[package]] name = "alloy-json-abi" version = "0.8.22" @@ -336,22 +445,60 @@ dependencies = [ "tracing", ] +[[package]] +name = "alloy-json-rpc" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-primitives", + "alloy-sol-types", + "serde", + "serde_json", + "thiserror 2.0.12", + "tracing", +] + [[package]] name = "alloy-network" version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f10b0bc0657b018ee4f3758f889d066af6b1f20f57cd825b540182029090c151" dependencies = [ - "alloy-consensus", - "alloy-consensus-any", - "alloy-eips", - "alloy-json-rpc", - "alloy-network-primitives", + "alloy-consensus 0.12.4", + "alloy-consensus-any 0.12.4", + "alloy-eips 0.12.4", + "alloy-json-rpc 0.12.4", + "alloy-network-primitives 0.12.4", + "alloy-primitives", + "alloy-rpc-types-any 0.12.4", + "alloy-rpc-types-eth 0.12.4", + "alloy-serde 0.12.4", + "alloy-signer 0.12.4", + "alloy-sol-types", + "async-trait", + "auto_impl", + "derive_more 2.0.1", + "futures-utils-wasm", + "serde", + "serde_json", + "thiserror 2.0.12", +] + +[[package]] +name = "alloy-network" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-consensus-any 0.12.5", + "alloy-eips 0.12.5", + "alloy-json-rpc 0.12.5", + "alloy-network-primitives 0.12.5", "alloy-primitives", - "alloy-rpc-types-any", - "alloy-rpc-types-eth", - "alloy-serde", - "alloy-signer", + "alloy-rpc-types-any 0.12.5", + "alloy-rpc-types-eth 0.12.5", + "alloy-serde 0.12.5", + "alloy-signer 0.12.5", "alloy-sol-types", "async-trait", "auto_impl", @@ -368,10 +515,22 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6cac4aeeabbbc16623d0745ae3b5a515d727ce8ef4ec4b6a886c3634d8b298fe" dependencies = [ - "alloy-consensus", - "alloy-eips", + "alloy-consensus 0.12.4", + "alloy-eips 0.12.4", + "alloy-primitives", + "alloy-serde 0.12.4", + "serde", +] + +[[package]] +name = "alloy-network-primitives" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-eips 0.12.5", "alloy-primitives", - "alloy-serde", + "alloy-serde 0.12.5", "serde", ] @@ -409,18 +568,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d06ffafc44e68c8244feb51919895c679c153a0b143c182e1ffe8cce998abf15" dependencies = [ "alloy-chains", - "alloy-consensus", - "alloy-eips", - "alloy-json-rpc", - "alloy-network", - "alloy-network-primitives", + "alloy-consensus 0.12.4", + "alloy-eips 0.12.4", + "alloy-json-rpc 0.12.4", + "alloy-network 0.12.4", + "alloy-network-primitives 0.12.4", "alloy-primitives", "alloy-pubsub", - "alloy-rpc-client", - "alloy-rpc-types-eth", + "alloy-rpc-client 0.12.4", + "alloy-rpc-types-eth 0.12.4", "alloy-sol-types", - "alloy-transport", - "alloy-transport-http", + "alloy-transport 0.12.4", + "alloy-transport-http 0.12.4", "alloy-transport-ws", "async-stream", "async-trait", @@ -441,15 +600,51 @@ dependencies = [ "wasmtimer", ] +[[package]] +name = "alloy-provider" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-chains", + "alloy-consensus 0.12.5", + "alloy-eips 0.12.5", + "alloy-json-rpc 0.12.5", + "alloy-network 0.12.5", + "alloy-network-primitives 0.12.5", + "alloy-primitives", + "alloy-rpc-client 0.12.5", + "alloy-rpc-types-eth 0.12.5", + "alloy-sol-types", + "alloy-transport 0.12.5", + "alloy-transport-http 0.12.5", + "async-stream", + "async-trait", + "auto_impl", + "dashmap", + "futures", + "futures-utils-wasm", + "lru 0.13.0", + "parking_lot", + "pin-project", + "reqwest 0.12.12", + "serde", + "serde_json", + "thiserror 2.0.12", + "tokio", + "tracing", + "url", + "wasmtimer", +] + [[package]] name = "alloy-pubsub" version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6abe9f9e6be75dc8532bb2bf3f4c700c9e7bce8a3b05ec702a7324abdb118016" dependencies = [ - "alloy-json-rpc", + "alloy-json-rpc 0.12.4", "alloy-primitives", - "alloy-transport", + "alloy-transport 0.12.4", "bimap", "futures", "serde", @@ -488,11 +683,11 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c9ae316fdb92a4546f0dba4919ea4c1c0edb89a876536520c248fada0febac5d" dependencies = [ - "alloy-json-rpc", + "alloy-json-rpc 0.12.4", "alloy-primitives", "alloy-pubsub", - "alloy-transport", - "alloy-transport-http", + "alloy-transport 0.12.4", + "alloy-transport-http 0.12.4", "alloy-transport-ws", "futures", "pin-project", @@ -507,6 +702,28 @@ dependencies = [ "wasmtimer", ] +[[package]] +name = "alloy-rpc-client" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-json-rpc 0.12.5", + "alloy-primitives", + "alloy-transport 0.12.5", + "alloy-transport-http 0.12.5", + "futures", + "pin-project", + "reqwest 0.12.12", + "serde", + "serde_json", + "tokio", + "tokio-stream", + "tower 0.5.2", + "tracing", + "url", + "wasmtimer", +] + [[package]] name = "alloy-rpc-types" version = "0.12.4" @@ -514,8 +731,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "61e50cc5a693dfbef452e3dbcea3cd3342840d10eb3ffa018b0a5676967d8b6b" dependencies = [ "alloy-primitives", - "alloy-rpc-types-eth", - "alloy-serde", + "alloy-rpc-types-eth 0.12.4", + "alloy-serde 0.12.4", + "serde", +] + +[[package]] +name = "alloy-rpc-types" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-primitives", + "alloy-rpc-types-eth 0.12.5", + "alloy-serde 0.12.5", "serde", ] @@ -525,9 +753,19 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f726ebb03d5918a946d0a6e17829cabd90ffe928664dc3f7fdbba1be511760de" dependencies = [ - "alloy-consensus-any", - "alloy-rpc-types-eth", - "alloy-serde", + "alloy-consensus-any 0.12.4", + "alloy-rpc-types-eth 0.12.4", + "alloy-serde 0.12.4", +] + +[[package]] +name = "alloy-rpc-types-any" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus-any 0.12.5", + "alloy-rpc-types-eth 0.12.5", + "alloy-serde 0.12.5", ] [[package]] @@ -536,13 +774,13 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c24a3b6c552b74c4abdbaa45fd467a230f5564f62c6adae16972dd90b6b4dca5" dependencies = [ - "alloy-consensus", - "alloy-consensus-any", - "alloy-eips", - "alloy-network-primitives", + "alloy-consensus 0.12.4", + "alloy-consensus-any 0.12.4", + "alloy-eips 0.12.4", + "alloy-network-primitives 0.12.4", "alloy-primitives", "alloy-rlp", - "alloy-serde", + "alloy-serde 0.12.4", "alloy-sol-types", "itertools 0.14.0", "serde", @@ -550,6 +788,25 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "alloy-rpc-types-eth" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-consensus-any 0.12.5", + "alloy-eips 0.12.5", + "alloy-network-primitives 0.12.5", + "alloy-primitives", + "alloy-rlp", + "alloy-serde 0.12.5", + "alloy-sol-types", + "itertools 0.13.0", + "serde", + "serde_json", + "thiserror 2.0.12", +] + [[package]] name = "alloy-serde" version = "0.12.4" @@ -561,6 +818,16 @@ dependencies = [ "serde_json", ] +[[package]] +name = "alloy-serde" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-primitives", + "serde", + "serde_json", +] + [[package]] name = "alloy-signer" version = "0.12.4" @@ -576,16 +843,30 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "alloy-signer" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-primitives", + "async-trait", + "auto_impl", + "either", + "elliptic-curve", + "k256", + "thiserror 2.0.12", +] + [[package]] name = "alloy-signer-local" version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "326033310c939b0d00b03fdbe2c243cb45add25c4e195d97b1792883c93a4c4c" dependencies = [ - "alloy-consensus", - "alloy-network", + "alloy-consensus 0.12.4", + "alloy-network 0.12.4", "alloy-primitives", - "alloy-signer", + "alloy-signer 0.12.4", "async-trait", "coins-bip32 0.12.0", "coins-bip39 0.12.0", @@ -594,6 +875,21 @@ dependencies = [ "thiserror 2.0.12", ] +[[package]] +name = "alloy-signer-local" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-consensus 0.12.5", + "alloy-network 0.12.5", + "alloy-primitives", + "alloy-signer 0.12.5", + "async-trait", + "k256", + "rand 0.8.5", + "thiserror 2.0.12", +] + [[package]] name = "alloy-sol-macro" version = "0.8.22" @@ -673,7 +969,25 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "463f6cb5234c7420e7e77c248c0460a8e2dea933f2bb4e8f169d5f12510b38e0" dependencies = [ - "alloy-json-rpc", + "alloy-json-rpc 0.12.4", + "base64 0.22.1", + "futures-utils-wasm", + "serde", + "serde_json", + "thiserror 2.0.12", + "tokio", + "tower 0.5.2", + "tracing", + "url", + "wasmtimer", +] + +[[package]] +name = "alloy-transport" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-json-rpc 0.12.5", "base64 0.22.1", "futures-utils-wasm", "serde", @@ -692,8 +1006,22 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1eacd1c195c2a706bfbc92113d4bd3481b0dbd1742923a232dbe8a7910ac0fe5" dependencies = [ - "alloy-json-rpc", - "alloy-transport", + "alloy-json-rpc 0.12.4", + "alloy-transport 0.12.4", + "reqwest 0.12.12", + "serde_json", + "tower 0.5.2", + "tracing", + "url", +] + +[[package]] +name = "alloy-transport-http" +version = "0.12.5" +source = "git+https://github.com/alloy-rs/alloy#b78ea8b06fe69b23fbafecc2c5ea3827b8328570" +dependencies = [ + "alloy-json-rpc 0.12.5", + "alloy-transport 0.12.5", "reqwest 0.12.12", "serde_json", "tower 0.5.2", @@ -708,7 +1036,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "218e64c375edd8fe8d00d9aa983fb2d85f7cfeebb91f707fe4c7ba52410803f5" dependencies = [ "alloy-pubsub", - "alloy-transport", + "alloy-transport 0.12.4", "futures", "http 1.2.0", "rustls 0.23.23", @@ -2882,7 +3210,7 @@ checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" name = "contract-bindings-alloy" version = "0.1.0" dependencies = [ - "alloy", + "alloy 0.12.5", ] [[package]] @@ -3833,7 +4161,7 @@ source = "git+https://github.com/espressosystems/espresso-systems-common?tag=0.4 name = "espresso-types" version = "0.1.0" dependencies = [ - "alloy", + "alloy 0.12.4", "anyhow", "ark-serialize 0.4.2", "async-broadcast", @@ -4058,7 +4386,7 @@ dependencies = [ name = "ethers-conv" version = "0.1.0" dependencies = [ - "alloy", + "alloy 0.12.4", "ethers", ] @@ -8236,9 +8564,9 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.20.3" +version = "1.21.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e" +checksum = "cde51589ab56b20a6f686b2c68f7a0bd6add753d697abf720d63f8db3ab7b1ad" [[package]] name = "oorandom" @@ -10287,7 +10615,7 @@ dependencies = [ name = "sequencer-utils" version = "0.1.0" dependencies = [ - "alloy", + "alloy 0.12.4", "anyhow", "ark-serialize 0.4.2", "async-trait",